fix(plugin): scope settings window routes to owning plugin

src/main/app/composition.ts

@@ -2796,7 +2796,7 @@ export async function createMainProcessControl(dependencies: {
       recordSettingsActivity: (input) => settingsDatabase.recordSettingsActivity(input)
     })
     const toolRoutes = createToolRoutes(toolService)
-    const pluginRoutes = createPluginRoutes(pluginService)
+    const pluginRoutes = createPluginRoutes(pluginService, pluginSettingsWindow)
     const skillRoutes = createSkillRoutes({
       skillService,
       skillSyncService,

src/main/desktop/pluginSettingsWindow.ts

@@ -1,9 +1,11 @@
 import { BrowserWindow } from 'electron'
 import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import type { PluginSettingsWindowPort } from '@/plugin'
 
 export class PluginSettingsWindow implements PluginSettingsWindowPort {
   private readonly windows = new Map<string, BrowserWindow>()
+  private readonly pluginIdByWebContentsId = new Map<number, string>()
 
   async open(input: { pluginId: string; title: string; entry: string }): Promise<void> {
     const existing = this.windows.get(input.pluginId)
@@ -23,19 +25,32 @@ export class PluginSettingsWindow implements PluginSettingsWindowPort {
         nodeIntegration: false,
         contextIsolation: true,
         preload: path.join(__dirname, '../preload/pluginSettings.mjs'),
-        sandbox: false
+        sandbox: false,
+        additionalArguments: [`--deepchat-plugin-id=${encodeURIComponent(input.pluginId)}`]
       }
     })
 
+    const webContentsId = settingsWindow.webContents.id
+    const entryPath = pathToFileURL(input.entry).pathname
     this.windows.set(input.pluginId, settingsWindow)
+    this.pluginIdByWebContentsId.set(webContentsId, input.pluginId)
     settingsWindow.webContents.setWindowOpenHandler(() => ({ action: 'deny' }))
+    settingsWindow.webContents.on('will-navigate', (event, url) => {
+      const target = new URL(url)
+      if (target.protocol !== 'file:' || target.pathname !== entryPath) {
+        event.preventDefault()
+      }
+    })
     settingsWindow.on('ready-to-show', () => {
       if (!settingsWindow.isDestroyed()) {
         settingsWindow.show()
       }
     })
     settingsWindow.on('closed', () => {
-      this.windows.delete(input.pluginId)
+      this.pluginIdByWebContentsId.delete(webContentsId)
+      if (this.windows.get(input.pluginId) === settingsWindow) {
+        this.windows.delete(input.pluginId)
+      }
     })
 
     await settingsWindow.loadFile(input.entry, {
@@ -45,6 +60,10 @@ export class PluginSettingsWindow implements PluginSettingsWindowPort {
     })
   }
 
+  getPluginIdForWebContents(webContentsId: number): string | null {
+    return this.pluginIdByWebContentsId.get(webContentsId) ?? null
+  }
+
   close(pluginId: string): void {
     const settingsWindow = this.windows.get(pluginId)
     if (settingsWindow && !settingsWindow.isDestroyed()) {

src/main/plugin/index.ts

@@ -80,6 +80,7 @@ export interface PluginSettingsWindowPort {
   open(input: { pluginId: string; title: string; entry: string }): Promise<void>
   close(pluginId: string): void
   closeAll(): void
+  getPluginIdForWebContents(webContentsId: number): string | null
 }
 
 type PluginServiceDeps = {

src/main/plugin/routes.ts

@@ -11,10 +11,25 @@ import {
   pluginsInvokeActionRoute,
   pluginsListRoute
 } from '@shared/contracts/routes'
-import { createRouteMap, type DeepchatRouteMap } from '@/routes/routeRegistry'
-import type { PluginServicePort } from './index'
+import { createRouteMap, type DeepchatRouteMap, type RouteContext } from '@/routes/routeRegistry'
+import type { PluginServicePort, PluginSettingsWindowPort } from './index'
+
+export function createPluginRoutes(
+  pluginService: PluginServicePort,
+  settingsWindow: PluginSettingsWindowPort
+): DeepchatRouteMap {
+  const assertPluginSettingsCallerOwns = (context: RouteContext, pluginId: string): void => {
+    if (context.caller.kind !== 'renderer') {
+      return
+    }
+    const ownerPluginId = settingsWindow.getPluginIdForWebContents(context.caller.webContentsId)
+    if (ownerPluginId != null && ownerPluginId !== pluginId) {
+      throw new Error(
+        `Plugin settings window for "${ownerPluginId}" cannot control plugin "${pluginId}"`
+      )
+    }
+  }
 
-export function createPluginRoutes(pluginService: PluginServicePort): DeepchatRouteMap {
   return createRouteMap([
     [
       pluginsInspectSourceRoute.name,
@@ -78,35 +93,39 @@ export function createPluginRoutes(pluginService: PluginServicePort): DeepchatRo
     ],
     [
       pluginsGetRoute.name,
-      async (rawInput) => {
+      async (rawInput, context) => {
         const input = pluginsGetRoute.input.parse(rawInput)
+        assertPluginSettingsCallerOwns(context, input.pluginId)
         return pluginsGetRoute.output.parse({
           plugin: await pluginService.getPlugin(input.pluginId)
         })
       }
     ],
     [
       pluginsEnableRoute.name,
-      async (rawInput) => {
+      async (rawInput, context) => {
         const input = pluginsEnableRoute.input.parse(rawInput)
+        assertPluginSettingsCallerOwns(context, input.pluginId)
         return pluginsEnableRoute.output.parse({
           result: await pluginService.enablePlugin(input.pluginId)
         })
       }
     ],
     [
       pluginsDisableRoute.name,
-      async (rawInput) => {
+      async (rawInput, context) => {
         const input = pluginsDisableRoute.input.parse(rawInput)
+        assertPluginSettingsCallerOwns(context, input.pluginId)
         return pluginsDisableRoute.output.parse({
           result: await pluginService.disablePlugin(input.pluginId)
         })
       }
     ],
     [
       pluginsInvokeActionRoute.name,
-      async (rawInput) => {
+      async (rawInput, context) => {
         const input = pluginsInvokeActionRoute.input.parse(rawInput)
+        assertPluginSettingsCallerOwns(context, input.pluginId)
         return pluginsInvokeActionRoute.output.parse({
           result: await pluginService.invokeAction(input.pluginId, input.actionId, input.payload)
         })

src/main/provider/auth/index.ts

@@ -397,6 +397,8 @@ export class OAuthService implements OAuthServicePort {
       const authUrl = this.buildAuthUrl(config)
       logger.info('Opening OAuth URL:', authUrl)
 
+      this.authWindow.webContents.setWindowOpenHandler(() => ({ action: 'deny' }))
+
       // Load authorization page
       this.authWindow.loadURL(authUrl)
       this.authWindow.show()

src/preload/plugin-settings-preload.ts

@@ -9,8 +9,13 @@ import {
 } from '@shared/contracts/routes'
 import type { PluginSettingsApiStatus } from '@shared/types/plugin'
 
+const PLUGIN_ID_ARG_PREFIX = '--deepchat-plugin-id='
+
 function readPluginId(): string {
-  const pluginId = new URL(window.location.href).searchParams.get('pluginId')?.trim()
+  const arg = process.argv.find((value) => value.startsWith(PLUGIN_ID_ARG_PREFIX))
+  const pluginId = arg
+    ? decodeURIComponent(arg.slice(PLUGIN_ID_ARG_PREFIX.length)).trim()
+    : undefined
   if (!pluginId) {
     throw new Error('Plugin settings renderer is missing pluginId')
   }

test/main/desktop/pluginSettingsWindow.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi } from 'vitest'
+import { BrowserWindow } from 'electron'
+import { PluginSettingsWindow } from '@/desktop/pluginSettingsWindow'
+
+type Handler = (...args: any[]) => void
+
+type FakeWindow = {
+  webContents: {
+    id: number
+    on: ReturnType<typeof vi.fn>
+    setWindowOpenHandler: ReturnType<typeof vi.fn>
+  }
+  isDestroyed: ReturnType<typeof vi.fn>
+  on: ReturnType<typeof vi.fn>
+  show: ReturnType<typeof vi.fn>
+  focus: ReturnType<typeof vi.fn>
+  close: ReturnType<typeof vi.fn>
+  loadFile: ReturnType<typeof vi.fn>
+  handlers: Map<string, Handler>
+  webContentsHandlers: Map<string, Handler>
+}
+
+function installBrowserWindowMock(): FakeWindow[] {
+  const created: FakeWindow[] = []
+  vi.mocked(BrowserWindow).mockImplementation(function () {
+    const handlers = new Map<string, Handler>()
+    const webContentsHandlers = new Map<string, Handler>()
+    const win: FakeWindow = {
+      webContents: {
+        id: 100 + created.length,
+        on: vi.fn((event: string, cb: Handler) => webContentsHandlers.set(event, cb)),
+        setWindowOpenHandler: vi.fn()
+      },
+      isDestroyed: vi.fn(() => false),
+      on: vi.fn((event: string, cb: Handler) => handlers.set(event, cb)),
+      show: vi.fn(),
+      focus: vi.fn(),
+      close: vi.fn(),
+      loadFile: vi.fn().mockResolvedValue(undefined),
+      handlers,
+      webContentsHandlers
+    }
+    created.push(win)
+    return win as any
+  })
+  return created
+}
+
+const input = { pluginId: 'p1', title: 'P1', entry: '/plugins/p1/settings.html' }
+
+describe('PluginSettingsWindow', () => {
+  it('keeps the reopened window record when a stale closed event fires late', async () => {
+    const created = installBrowserWindowMock()
+    const settingsWindow = new PluginSettingsWindow()
+
+    await settingsWindow.open(input)
+    settingsWindow.close(input.pluginId)
+    await settingsWindow.open(input)
+
+    created[0].handlers.get('closed')?.()
+
+    settingsWindow.close(input.pluginId)
+    expect(created[1].close).toHaveBeenCalled()
+    expect(settingsWindow.getPluginIdForWebContents(created[1].webContents.id)).toBe('p1')
+  })
+
+  it('restricts navigation to the file entry', async () => {
+    const created = installBrowserWindowMock()
+    const settingsWindow = new PluginSettingsWindow()
+
+    await settingsWindow.open(input)
+
+    const onWillNavigate = created[0].webContentsHandlers.get('will-navigate')
+    expect(onWillNavigate).toBeDefined()
+
+    const isAllowed = (url: string): boolean => {
+      const event = { preventDefault: vi.fn() }
+      onWillNavigate?.(event, url)
+      return event.preventDefault.mock.calls.length === 0
+    }
+
+    expect(isAllowed('file:///plugins/p1/settings.html?pluginId=p1')).toBe(true)
+    expect(isAllowed('file:///plugins/p1/settings.html#section')).toBe(true)
+    expect(isAllowed('file:///plugins/other/settings.html')).toBe(false)
+    expect(isAllowed('https://example.com/')).toBe(false)
+  })
+})

test/main/plugin/pluginRoutes.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from 'vitest'
+import {
+  pluginsDisableRoute,
+  pluginsEnableRoute,
+  pluginsGetRoute,
+  pluginsInvokeActionRoute
+} from '@shared/contracts/routes'
+import type { PluginServicePort, PluginSettingsWindowPort } from '@/plugin'
+import { createPluginRoutes } from '@/plugin/routes'
+import { createRendererRouteContext, type RouteContext } from '@/routes/routeRegistry'
+
+const actionResult = { ok: true }
+
+function setup(ownerPluginId: string | null) {
+  const pluginService = {
+    enablePlugin: vi.fn().mockResolvedValue(actionResult),
+    disablePlugin: vi.fn().mockResolvedValue(actionResult),
+    invokeAction: vi.fn().mockResolvedValue(actionResult),
+    getPlugin: vi.fn().mockResolvedValue({ id: 'plugin-a' })
+  }
+  const settingsWindow: PluginSettingsWindowPort = {
+    open: async () => {},
+    close: () => {},
+    closeAll: () => {},
+    getPluginIdForWebContents: () => ownerPluginId
+  }
+  const routes = createPluginRoutes(pluginService as unknown as PluginServicePort, settingsWindow)
+  return { pluginService, routes }
+}
+
+const pluginWindowContext = (): RouteContext => createRendererRouteContext(42, 7)
+
+describe('createPluginRoutes settings-window ownership', () => {
+  it('rejects disable for another plugin from a plugin settings window', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsDisableRoute.name)
+
+    await expect(handler?.({ pluginId: 'plugin-b' }, pluginWindowContext())).rejects.toThrow(
+      /cannot control plugin/
+    )
+    expect(pluginService.disablePlugin).not.toHaveBeenCalled()
+  })
+
+  it('rejects enable for another plugin from a plugin settings window', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsEnableRoute.name)
+
+    await expect(handler?.({ pluginId: 'plugin-b' }, pluginWindowContext())).rejects.toThrow(
+      /cannot control plugin/
+    )
+    expect(pluginService.enablePlugin).not.toHaveBeenCalled()
+  })
+
+  it('rejects invokeAction for another plugin from a plugin settings window', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsInvokeActionRoute.name)
+
+    await expect(
+      handler?.({ pluginId: 'plugin-b', actionId: 'act' }, pluginWindowContext())
+    ).rejects.toThrow(/cannot control plugin/)
+    expect(pluginService.invokeAction).not.toHaveBeenCalled()
+  })
+
+  it('rejects get for another plugin from a plugin settings window', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsGetRoute.name)
+
+    await expect(handler?.({ pluginId: 'plugin-b' }, pluginWindowContext())).rejects.toThrow(
+      /cannot control plugin/
+    )
+    expect(pluginService.getPlugin).not.toHaveBeenCalled()
+  })
+
+  it('allows a plugin settings window to control its own plugin', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsDisableRoute.name)
+
+    await handler?.({ pluginId: 'plugin-a' }, pluginWindowContext())
+
+    expect(pluginService.disablePlugin).toHaveBeenCalledWith('plugin-a')
+  })
+
+  it('allows renderer callers that are not plugin settings windows', async () => {
+    const { pluginService, routes } = setup(null)
+    const handler = routes.get(pluginsDisableRoute.name)
+
+    await handler?.({ pluginId: 'plugin-b' }, pluginWindowContext())
+
+    expect(pluginService.disablePlugin).toHaveBeenCalledWith('plugin-b')
+  })
+
+  it('allows non-renderer callers', async () => {
+    const { pluginService, routes } = setup('plugin-a')
+    const handler = routes.get(pluginsEnableRoute.name)
+    const context: RouteContext = { caller: { kind: 'internal', component: 'scheduler' } }
+
+    await handler?.({ pluginId: 'plugin-b' }, context)
+
+    expect(pluginService.enablePlugin).toHaveBeenCalledWith('plugin-b')
+  })
+})

test/main/routes/dispatcher.test.ts

@@ -1616,7 +1616,12 @@ function createRuntime() {
     recordSettingsActivity: (input) => sqlitePresenter.recordSettingsActivity(input)
   })
   const toolRoutes = createToolRoutes(toolService)
-  const pluginRoutes = createPluginRoutes(pluginService)
+  const pluginRoutes = createPluginRoutes(pluginService, {
+    open: async () => {},
+    close: () => {},
+    closeAll: () => {},
+    getPluginIdForWebContents: () => null
+  })
   const assertSessionActiveSkillsMutable = vi.fn().mockResolvedValue(undefined)
   const skillRoutes = createSkillRoutes({
     skillService,