chore: update

Author: zhangmo8

docs/issues/plugin-settings-surface-isolation/plan.md

@@ -13,8 +13,16 @@
   official manifest, even if the version string is unchanged.
 - Preserve plugin-local `config.json` when reinstalling a stale official plugin so credentials do
   not disappear during self-healing.
+- When discovery rejects an installed official plugin as unsupported or untrusted, remove the
+  persisted installation record and disable plugin-owned MCP servers, settings resources, and tool
+  policies before initialization tries to reactivate them.
 - Keep Feishu's MCP bootstrap self-contained with only Node builtins in the installed entrypoint,
   and use a built-in stdio warning responder when credentials are missing.
+- Clear the Feishu settings page message banner on non-error MCP states so prior failures do not
+  linger after recovery.
+- Pin the Feishu `npx` package invocation and only pass through an explicit registry override from
+  the environment.
+- Replace Feishu's blanket MCP auto-approval with an empty default allowlist.
 - Resolve settings contributions from the current official manifest instead of trusting an older
   installed manifest copy, while still reusing installed file paths when those assets exist.
 - Resolve plugin settings contributions from the installed plugin manifest when stored plugin
@@ -30,6 +38,9 @@
 ## Affected Areas
 
 - `src/main/presenter/pluginPresenter/index.ts`
+- `plugins/feishu/settings/assets/index.js`
+- `plugins/feishu/mcp/serve.mjs`
+- `plugins/feishu/plugin.json`
 - `src/renderer/src/components/mcp-config/components/McpServers.vue`
 - Focused presenter and renderer regression tests
 
@@ -41,8 +52,12 @@
 - Add a main-process regression test covering opening settings for a disabled packaged plugin.
 - Add a main-process regression test covering startup self-heal for stale same-version installs.
 - Add a main-process regression test covering dev-directory sync when only plugin files changed.
+- Add a main-process regression test covering cleanup when discovery rejects a persisted official
+  plugin installation.
 - Add a regression assertion that the Feishu installed MCP bootstrap does not statically import host
   SDK packages.
+- Add focused Feishu regression assertions for the pinned bootstrap package version, registry
+  override behavior, safer auto-approve defaults, and stale settings error clearing.
 - Add a renderer regression test covering plugin-owned MCP servers being hidden from the global MCP
   settings list.
 

docs/issues/plugin-settings-surface-isolation/spec.md

@@ -18,13 +18,20 @@ instead of being mixed into the existing global settings or MCP settings surface
   cannot survive on version equality alone.
 - In development, official plugin directory installs stay synchronized with workspace files even when
   only non-manifest files changed.
+- Discovery that rejects an official plugin as unsupported or untrusted clears its persisted
+  installation record and plugin-owned runtime resources before startup activation can reuse them.
 - Enabling an official plugin with a declared settings contribution exposes the plugin settings
   action on the Plugins settings page without depending on previously persisted resource records.
 - Opening plugin settings still works when persisted plugin resource records are missing or stale,
   as long as the installed plugin manifest still declares a valid settings contribution.
 - Reinstalling a stale official plugin preserves plugin-local configuration such as `config.json`.
 - Plugin-owned MCP entrypoints remain runnable after installation into userData and must not rely on
   static imports from the workspace or app-level `node_modules`.
+- The Feishu plugin settings page clears stale MCP error text whenever the Feishu MCP is not in an
+  error state.
+- The Feishu MCP bootstrap launches a pinned upstream package version and only honors explicit
+  registry overrides instead of injecting a hardcoded registry fallback.
+- The Feishu plugin manifest does not auto-approve every MCP tool call by default.
 - Global MCP settings do not render plugin-owned MCP servers identified by `source: plugin`.
 - Plugin-owned MCP runtime status remains available from plugin-specific settings/status surfaces.
 

docs/issues/plugin-settings-surface-isolation/tasks.md

@@ -6,7 +6,12 @@
 - [x] Prefer workspace official plugin directories over stale installed copies during dev discovery.
 - [x] Reinstall stale same-version official plugins and preserve `config.json` during refresh.
 - [x] Keep dev directory plugin installs synced even when only file contents changed.
+- [x] Clear persisted plugin installation state when discovery rejects unsupported or untrusted
+	official plugins.
 - [x] Keep Feishu installed MCP bootstrap self-contained and free of static host SDK imports.
+- [x] Clear stale MCP error text from the Feishu settings page after healthy status refreshes.
+- [x] Pin the Feishu MCP bootstrap package and remove the hardcoded registry fallback.
+- [x] Replace Feishu's blanket MCP auto-approve default with an empty allowlist.
 - [x] Hide plugin-owned MCP servers from the global MCP settings list.
 - [x] Add focused regression coverage for presenter and renderer behavior.
 - [x] Run focused validation and repo-required format/i18n/lint checks as feasible.

plugins/feishu/mcp/serve.mjs

@@ -8,6 +8,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const pluginRoot = join(__dirname, '..')
 const WARNING_TEXT =
   'Feishu/Lark credentials are not configured. Please open the plugin settings and set your App ID and App Secret, then restart the MCP server.'
+const LARK_MCP_PACKAGE = '@larksuiteoapi/lark-mcp@0.5.1'
 
 function loadConfig() {
   const configPath = join(pluginRoot, 'config.json')
@@ -151,8 +152,20 @@ function startWarningServer() {
   process.stdin.resume()
 }
 
+function resolveSpawnEnv() {
+  const registryOverride = process.env.REGISTRY_OVERRIDE?.trim()
+  if (!registryOverride) {
+    return process.env
+  }
+
+  return {
+    ...process.env,
+    npm_config_registry: registryOverride
+  }
+}
+
 function startConfiguredServer() {
-  const args = ['-y', '@larksuiteoapi/lark-mcp', 'mcp', '-a', appId, '-s', appSecret]
+  const args = ['-y', LARK_MCP_PACKAGE, 'mcp', '-a', appId, '-s', appSecret]
   if (brand === 'lark') {
     args.push('--domain', 'https://open.larksuite.com')
   }
@@ -162,10 +175,7 @@ function startConfiguredServer() {
 
   const child = spawn('npx', args, {
     stdio: 'inherit',
-    env: {
-      ...process.env,
-      npm_config_registry: process.env.npm_config_registry || 'https://registry.npmmirror.com'
-    }
+    env: resolveSpawnEnv()
   })
 
   child.on('error', (error) => {

plugins/feishu/plugin.json

@@ -22,7 +22,7 @@
       "command": "node",
       "args": ["${plugin.root}/mcp/serve.mjs"],
       "env": {},
-      "autoApprove": ["all"]
+      "autoApprove": []
     }
   ],
   "skills": [

plugins/feishu/settings/assets/index.js

@@ -43,15 +43,22 @@ async function refreshStatus() {
   const mcp = status.mcpServers?.find((s) => s.serverId === 'feishu-tools')
   if (!mcp) {
     setText(mcpStateNode, 'Unavailable')
-  } else if (mcp.lastError) {
-    setText(mcpStateNode, 'Error')
-    setMessage(mcp.lastError)
   } else if (mcp.running) {
     setText(mcpStateNode, 'Running')
+    setMessage('')
   } else if (mcp.enabled) {
     setText(mcpStateNode, 'Stopped')
+    setMessage('')
+  } else if (mcp.lastError) {
+    setText(mcpStateNode, 'Error')
+    setMessage(mcp.lastError)
   } else {
     setText(mcpStateNode, 'Disabled')
+    setMessage('')
+  }
+
+  if (!mcp) {
+    setMessage('')
   }
 }
 

src/main/presenter/pluginPresenter/index.ts

@@ -307,6 +307,12 @@ export class PluginPresenter {
     this.removeResourceRecordsByOwner(pluginId)
   }
 
+  private async removePersistedInstallation(pluginId: string): Promise<void> {
+    await this.disableByOwner(pluginId)
+    this.removeInstallationRecord(pluginId)
+    this.removeRuntimeRecordsByOwner(pluginId)
+  }
+
   private async registerMcpServers(
     plugin: ResolvedOfficialPlugin,
     runtime?: PluginRuntimeStatus
@@ -753,12 +759,14 @@ export class PluginPresenter {
       }
       if (!this.isPluginPlatformSupported(plugin.manifest)) {
         console.info(`[PluginHost] Skipping plugin ${plugin.manifest.id}: platform not supported`)
+        await this.removePersistedInstallation(plugin.manifest.id)
         continue
       }
       try {
         this.assertTrustedOfficialPlugin(plugin.manifest)
       } catch (error) {
         console.warn(`[PluginHost] Skipping untrusted plugin ${plugin.manifest.id}:`, error)
+        await this.removePersistedInstallation(plugin.manifest.id)
         continue
       }
       console.info(`[PluginHost] Discovered plugin: ${plugin.manifest.id} at ${plugin.root}`)
@@ -1191,6 +1199,13 @@ export class PluginPresenter {
     return this.getInstallations().find((installation) => installation.pluginId === pluginId)
   }
 
+  private removeInstallationRecord(pluginId: string): void {
+    this.store.set(
+      'installations',
+      this.getInstallations().filter((installation) => installation.pluginId !== pluginId)
+    )
+  }
+
   private upsertInstallation(record: PluginInstallationRecord): void {
     this.store.set('installations', [
       ...this.getInstallations().filter((item) => item.pluginId !== record.pluginId),
@@ -1247,6 +1262,13 @@ export class PluginPresenter {
     )
   }
 
+  private removeRuntimeRecordsByOwner(pluginId: string): void {
+    this.store.set(
+      'runtimes',
+      (this.store.get('runtimes') ?? []).filter((runtime) => runtime.pluginId !== pluginId)
+    )
+  }
+
   private upsertRuntimeRecord(record: RuntimeDependencyRecord): void {
     this.store.set('runtimes', [
       ...(this.store.get('runtimes') ?? []).filter(

test/main/presenter/pluginPresenter.test.ts

@@ -618,6 +618,51 @@ describe('PluginPresenter', () => {
     expect(presenter.__mocks.mcpPresenter.startServer).toHaveBeenCalledWith('fixture-tools')
   })
 
+  it('removes persisted plugin state when discovery rejects an installed official plugin', async () => {
+    const fixture = await createDirectoryFixture()
+    const workspaceManifestPath = path.join(fixture.pluginRoot, 'plugin.json')
+    const manifest = JSON.parse(await readFile(workspaceManifestPath, 'utf8'))
+    manifest.toolPolicies = [
+      {
+        serverId: 'fixture-tools',
+        tools: {
+          fixture_tool: 'ask'
+        }
+      }
+    ]
+    await writeFile(workspaceManifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
+
+    const presenter = await createPluginPresenter('darwin', fixture.appPath)
+    const { getPluginToolPolicy } = await import('@/presenter/pluginPresenter/toolPolicyStore')
+
+    const enabled = await presenter.enablePlugin(fixture.pluginId)
+    expect(enabled.ok).toBe(true)
+    expect(getPluginToolPolicy('fixture-tools', 'fixture_tool')).toBe('ask')
+
+    const rejectedManifest = {
+      ...manifest,
+      engines: {
+        ...manifest.engines,
+        platforms: ['linux']
+      }
+    }
+    await writeFile(workspaceManifestPath, `${JSON.stringify(rejectedManifest, null, 2)}\n`)
+    await writeFile(
+      path.join(fixture.installedRoot, 'plugin.json'),
+      `${JSON.stringify(rejectedManifest, null, 2)}\n`
+    )
+
+    await presenter.initialize()
+
+    const servers = await presenter.__mocks.configPresenter.getMcpServers()
+
+    expect((presenter as any).store.get('installations')).toEqual([])
+    expect((presenter as any).store.get('resources')).toEqual([])
+    expect((presenter as any).store.get('runtimes')).toEqual([])
+    expect(servers['fixture-tools']).toBeUndefined()
+    expect(getPluginToolPolicy('fixture-tools', 'fixture_tool')).toBeNull()
+  })
+
   it('loads official packages only from resources roots in packaged mode', async () => {
     const cwdRoot = await mkdtemp(path.join(os.tmpdir(), 'deepchat-plugin-cwd-'))
     tempRoots.push(cwdRoot)
@@ -885,13 +930,27 @@ describe('PluginPresenter', () => {
     }
   })
 
-  it('keeps the Feishu MCP bootstrap self-contained for installed plugin copies', async () => {
+  it('pins the Feishu MCP bootstrap package and keeps registry selection explicit', async () => {
     const source = await readFile('plugins/feishu/mcp/serve.mjs', 'utf8')
 
     expect(source).not.toContain('@modelcontextprotocol/sdk')
     expect(source).toContain('Content-Length:')
-    expect(source).toContain('npm_config_registry')
-    expect(source).toContain('registry.npmmirror.com')
+    expect(source).toContain('@larksuiteoapi/lark-mcp@0.5.1')
+    expect(source).toContain('REGISTRY_OVERRIDE')
+    expect(source).not.toContain('registry.npmmirror.com')
+  })
+
+  it('uses conservative Feishu MCP defaults in the plugin manifest', async () => {
+    const manifest = JSON.parse(await readFile('plugins/feishu/plugin.json', 'utf8'))
+
+    expect(manifest.mcpServers).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          id: 'feishu-tools',
+          autoApprove: []
+        })
+      ])
+    )
   })
 
   it('declares a Feishu plugin skill for MCP tool routing', async () => {