dsh-plugin-capabilities 0.1.1 → 0.1.2

package/src/client/McpTab.tsx

@@ -28,7 +28,7 @@ export interface McpInjected {
   remove(id: string): Promise<{ ok: boolean }>
   scanImport(): Promise<{ servers: ImportedServerView[]; existing: string[] }>
   applyImport(items: Array<{ agent: string; name: string }>): Promise<{ ok: boolean; results: Array<{ name: string; ok: boolean; error?: string }> }>
-  restart(): void
+  restart(): Promise<void>
   desktop: boolean
 }
 
@@ -71,6 +71,8 @@ export function McpTab(props: { t: Translate; injected: McpInjected }): ReactEle
   const [importItems, setImportItems] = useState<Array<{ server: ImportedServerView; existing: boolean; checked: boolean }> | null>(null)
   const [busy, setBusy] = useState(false)
   const [pending, setPending] = useState(false)
+  const [restartConfirm, setRestartConfirm] = useState(false)
+  const [restarting, setRestarting] = useState(false)
   const [outcome, setOutcome] = useState<{ ok: boolean; text: string } | null>(null)
   const [formError, setFormError] = useState<string | null>(null)
   const [reload, setReload] = useState(0)
@@ -203,15 +205,36 @@ export function McpTab(props: { t: Translate; injected: McpInjected }): ReactEle
     }
   }
 
+  const doRestart = (): void => {
+    setRestartConfirm(false)
+    setRestarting(true)
+    void injected.restart()
+    // 桌面模式：壳层重启完成后会重载窗口。独立模式：轮询本源，恢复即刷新。
+    if (injected.desktop) return
+    const deadline = Date.now() + 60_000
+    const poll = (): void => {
+      if (Date.now() > deadline) return
+      window.setTimeout(() => {
+        void injected.list().then(
+          () => { window.location.reload() },
+          () => { poll() },
+        )
+      }, 1500)
+    }
+    window.setTimeout(poll, 3000)
+  }
+
   const restartBanner = (
     <div className="dpc-banner" data-kind="info" role="status">
       <StateDot state="ongoing" size={10} />
       <div className="dpc-bannerBody">
-        <span>{t('restartNeeded')}</span>
+        <span>{restarting ? t('restarting') : t('restartNeeded')}</span>
         <span className="dpc-bannerHint">
-          {injected.desktop
-            ? <>{t('restartDesktopHint')}{' '}<Button variant="outline" size="sm" onClick={injected.restart}>{t('restartNow')}</Button></>
-            : t('restartOtherHint')}
+          {restarting
+            ? (!injected.desktop && t('restartPortHint'))
+            : injected.desktop
+              ? <>{t('restartDesktopHint')}{' '}<Button variant="outline" size="sm" onClick={() => setRestartConfirm(true)}>{t('restartNow')}</Button></>
+              : t('restartOtherHint')}
         </span>
       </div>
     </div>
@@ -225,6 +248,7 @@ export function McpTab(props: { t: Translate; injected: McpInjected }): ReactEle
         <IconApiOutline14 aria-hidden="true" />
         <h3>{t('mcpTitle')}</h3>
         <span className="dpc-spacer" />
+        <Button variant="ghost" size="sm" disabled={restarting} onClick={() => setRestartConfirm(true)}>{t('restart')}</Button>
         <Button variant="ghost" size="sm" onClick={() => void openImport()}>{t('importServers')}</Button>
         <Button variant="primary" size="sm" onClick={openCreate}>{t('addServer')}</Button>
       </div>
@@ -236,7 +260,7 @@ export function McpTab(props: { t: Translate; injected: McpInjected }): ReactEle
           <div className="dpc-bannerBody"><span>{outcome.text}</span></div>
         </div>
       )}
-      {pending && restartBanner}
+      {(pending || restarting) && restartBanner}
 
       <div className="dpc-listHead">
         <h3>{t('mcpTab')}</h3>
@@ -352,6 +376,20 @@ export function McpTab(props: { t: Translate; injected: McpInjected }): ReactEle
         <p>{t('removeWarn')}</p>
       </Modal>
 
+      <Modal
+        open={restartConfirm}
+        onClose={() => setRestartConfirm(false)}
+        title={t('restartConfirmTitle')}
+        footer={
+          <>
+            <Button variant="ghost" onClick={() => setRestartConfirm(false)}>{t('cancel')}</Button>
+            <Button variant="primary" onClick={doRestart}>{t('restartNow')}</Button>
+          </>
+        }
+      >
+        <p>{t('restartConfirmBody')}</p>
+      </Modal>
+
       <Modal
         open={importOpen}
         onClose={() => setImportOpen(false)}

package/src/client/index.ts

@@ -80,7 +80,14 @@ export function apply(ctx: CapabilitiesClientContext): void {
     scanImport: () => fetchJson<{ servers: ImportedServerView[]; existing: string[] }>('/dsh-plugin-capabilities/import/scan'),
     applyImport: (items: Array<{ agent: string; name: string }>) =>
       post('/dsh-plugin-capabilities/import/apply', { items }) as Promise<{ ok: boolean; results: Array<{ name: string; ok: boolean; error?: string }> }>,
-    restart: (): void => { window.dshDesktop?.restartSidecar?.() },
+    restart: async (): Promise<void> => {
+      if (window.dshDesktop !== undefined) {
+        window.dshDesktop.restartSidecar?.()
+        return
+      }
+      // 独立 dsh web：自重启路由。连接在关停途中断开属预期，不算失败。
+      try { await post('/dsh-plugin-capabilities/restart', {}) } catch { /* dying mid-restart is expected */ }
+    },
     desktop: window.dshDesktop !== undefined,
   }
 

package/src/client/locales.ts

@@ -62,6 +62,11 @@ export const zh = {
   restartDesktopHint: '重启由桌面应用负责：托盘菜单「重启服务」。',
   restartOtherHint: '重启方式：关闭当前 dsh 进程后重新运行。',
   restartNow: '重启服务',
+  restart: '重启',
+  restartConfirmTitle: '重启 dsh？',
+  restartConfirmBody: '重启会中断正在进行的回合，未保存的输入可能丢失；MCP 行的变更将在重启后生效。',
+  restarting: '正在重启，恢复后将自动刷新页面…',
+  restartPortHint: '若重启后页面长时间未恢复，可能是端口已变化：在终端查看新地址后打开。',
   failed: '操作失败',
 }
 
@@ -127,5 +132,10 @@ export const en = {
   restartDesktopHint: 'The desktop app owns restarts: use the tray “Restart service”.',
   restartOtherHint: 'Restart by closing this dsh process and running it again.',
   restartNow: 'Restart service',
+  restart: 'Restart',
+  restartConfirmTitle: 'Restart dsh?',
+  restartConfirmBody: 'Restarting interrupts any running turn and may lose unsaved input; pending MCP changes apply after the restart.',
+  restarting: 'Restarting — the page will reload once the host is back…',
+  restartPortHint: 'If the page does not recover, the port may have changed: check the terminal for the new URL.',
   failed: 'Operation failed',
 }

package/src/restart.test.ts

@@ -0,0 +1,52 @@
+import type { IncomingMessage } from 'node:http'
+import { resolve } from 'node:path'
+import { describe, expect, it } from 'vitest'
+import { dshLaunch, restartOwnedByShell, trustedRestartRequest } from './restart.ts'
+
+describe('dshLaunch', () => {
+  it('replays an absolute bin entry with execArgv, runtime args, and cwd beside it', () => {
+    const launch = dshLaunch(
+      ['node', '/repo/apps/cli/src/bin.ts', 'web', '--port', '0'],
+      ['--expose-internals', '--import', 'tsx/esm'],
+    )
+    expect(launch.file).toBe(process.execPath)
+    expect(launch.args).toEqual(['--expose-internals', '--import', 'tsx/esm', resolve('/repo/apps/cli/src/bin.ts'), 'web', '--port', '0'])
+    expect(launch.cwd).toBe(resolve('/repo/apps/cli/src'))
+    expect(launch.viaShell).toBe(false)
+  })
+  it('resolves a relative source entry to an absolute path', () => {
+    const launch = dshLaunch(['node', 'apps/cli/src/bin.js'], [])
+    expect(launch.args[0]).toMatch(/^(?:[A-Za-z]:)?[\\/]/)
+    expect(launch.cwd).toBe(launch.args[0].replace(/[\\/]bin\.js$/, ''))
+  })
+  it('falls back to the bare dsh shim for unknown entries, keeping runtime args', () => {
+    expect(dshLaunch(['node', '/somewhere/server.js', 'web'])).toMatchObject({ file: 'dsh', args: ['web'], viaShell: process.platform === 'win32' })
+    expect(dshLaunch(['node'])).toMatchObject({ file: 'dsh', args: [] })
+  })
+})
+
+const request = (headers: Record<string, string | undefined>, address = '127.0.0.1'): IncomingMessage =>
+  ({ headers, socket: { remoteAddress: address } }) as unknown as IncomingMessage
+
+describe('trustedRestartRequest', () => {
+  it('accepts a direct same-origin loopback request', () => {
+    expect(trustedRestartRequest(request({ origin: 'http://127.0.0.1:8080', host: '127.0.0.1:8080' }))).toBe(true)
+  })
+  it('rejects non-loopback peers and proxy forwarding traces', () => {
+    expect(trustedRestartRequest(request({ origin: 'http://127.0.0.1:8080', host: '127.0.0.1:8080' }, '192.168.1.5'))).toBe(false)
+    expect(trustedRestartRequest(request({ origin: 'http://127.0.0.1:8080', host: '127.0.0.1:8080', 'x-forwarded-for': '1.2.3.4' }))).toBe(false)
+  })
+  it('rejects cross-origin or missing origin/host', () => {
+    expect(trustedRestartRequest(request({ origin: 'http://evil.example', host: '127.0.0.1:8080' }))).toBe(false)
+    expect(trustedRestartRequest(request({ host: '127.0.0.1:8080' }))).toBe(false)
+    expect(trustedRestartRequest(request({ origin: 'http://127.0.0.1:8080' }))).toBe(false)
+  })
+})
+
+describe('restartOwnedByShell', () => {
+  it('is true only under the desktop marker', () => {
+    expect(restartOwnedByShell({ DSH_DESKTOP: '1' })).toBe(true)
+    expect(restartOwnedByShell({ DSH_DESKTOP: '' })).toBe(false)
+    expect(restartOwnedByShell({})).toBe(false)
+  })
+})

package/src/restart.ts

@@ -0,0 +1,94 @@
+/**
+ * Self-restart for standalone `dsh web`: relaunch the exact invocation that
+ * booted this host, then stop this process — so MCP row changes compose
+ * without leaving the UI. The desktop shell owns restarts there
+ * (DSH_DESKTOP=1 refuses this path — a supervised sidecar must never
+ * replace itself, or the supervisor respawns a second process).
+ *
+ * The replacement is spawned directly with windowsHide: CREATE_NO_WINDOW
+ * gives it a hidden console its own console children inherit (no popping
+ * windows), unlike a DETACHED_PROCESS spawn which leaves children to create
+ * visible consoles. No helper process and no powershell wrapper — on at
+ * least one machine a node→node→powershell→node chain was silently blocked
+ * by host software before the inner node could even start, while direct
+ * node→node spawns are the most battle-tested pattern there is.
+ */
+
+import { spawn } from 'node:child_process'
+import { openSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, resolve } from 'node:path'
+import type { IncomingMessage } from 'node:http'
+
+/** The boot invocation to replay: entry from argv, execArgv preserved. */
+export function dshLaunch(argv: readonly string[] = process.argv, execArgv: readonly string[] = process.execArgv): {
+  file: string
+  args: string[]
+  cwd: string | undefined
+  viaShell: boolean
+} {
+  const entry = argv[1]
+  if (entry !== undefined && /[\\/](?:bin\.(?:js|ts)|dsh)$/.test(entry)) {
+    // Source launches (`pnpm dsh`) pass a relative entry that the child would
+    // resolve against its OWN cwd — absolutize, and keep cwd near the entry
+    // so execArgv module hooks (tsx/esm) stay resolvable.
+    const abs = resolve(entry)
+    return { file: process.execPath, args: [...execArgv, abs, ...argv.slice(2)], cwd: dirname(abs), viaShell: false }
+  }
+  // Bare `dsh` on Windows is a .cmd shim only a shell can start.
+  return { file: 'dsh', args: [...argv.slice(2)], cwd: undefined, viaShell: process.platform === 'win32' }
+}
+
+/**
+ * Relaunch this exact dsh invocation, then stop this process. The replacement
+ * boots slowly (module loading) while this process dies within 500 ms, so
+ * port handover needs no delay even for fixed-port launches. Replacement
+ * output is logged under tmpdir for post-mortem.
+ */
+export function scheduleRestart(launch: ReturnType<typeof dshLaunch>): {
+  pid: number
+  replacementPid: number | undefined
+  logOut: string
+  logErr: string
+} {
+  const stamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+  const logOut = `${tmpdir()}${tmpdir().endsWith('/') ? '' : '\\'}dsh-plugin-capabilities-restart-${stamp}.out.log`
+  const logErr = logOut.replace('.out.log', '.err.log')
+  const child = spawn(launch.file, launch.args, {
+    cwd: launch.cwd,
+    stdio: ['ignore', openSync(logOut, 'a'), openSync(logErr, 'a')],
+    env: process.env,
+    shell: launch.viaShell,
+    windowsHide: true,
+  })
+  child.unref()
+  setTimeout(() => process.kill(process.pid, 'SIGTERM'), 500)
+  return { pid: process.pid, replacementPid: child.pid, logOut, logErr }
+}
+
+/**
+ * A restart request is process control: only a direct same-origin loopback
+ * request qualifies. Any forwarding trace means the loopback peer is a
+ * proxy, not the user's browser.
+ */
+export function trustedRestartRequest(request: IncomingMessage, socketAddress?: string): boolean {
+  const address = socketAddress ?? (request.socket.remoteAddress ?? '')
+  if (address !== '127.0.0.1' && address !== '::1' && address !== '::ffff:127.0.0.1') return false
+  if (request.headers.forwarded !== undefined
+    || request.headers['x-forwarded-for'] !== undefined
+    || request.headers['x-real-ip'] !== undefined) return false
+  const origin = request.headers.origin
+  const host = request.headers.host
+  if (origin === undefined || host === undefined) return false
+  try {
+    const parsed = new URL(origin)
+    return (parsed.protocol === 'http:' || parsed.protocol === 'https:') && parsed.host === host
+  } catch {
+    return false
+  }
+}
+
+/** Restart ownership: the desktop shell supervises the sidecar and restarts it. */
+export function restartOwnedByShell(env: NodeJS.ProcessEnv = process.env): boolean {
+  return env.DSH_DESKTOP === '1'
+}

package/src/routes.ts

@@ -3,6 +3,7 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import { scanAllMcp } from './agents.ts'
 import { readJsonBody, sameOrigin, sendJson } from './http.ts'
+import { dshLaunch, restartOwnedByShell, scheduleRestart, trustedRestartRequest } from './restart.ts'
 import { deleteSkill, validateSkillInput, writeSkill, type SkillInput } from './skills.ts'
 import { listMcp, removeMcp, setMcpDisabled, upsertMcp, validateMcpInput, type McpInput } from './mcp.ts'
 import type { CapabilitiesHost } from './types.ts'
@@ -279,6 +280,29 @@ export function mountCapabilitiesRoutes(host: CapabilitiesHost, config: { profil
         }
       },
     }),
+
+    host.webServer.register({
+      kind: 'exact',
+      path: '/dsh-plugin-capabilities/restart',
+      handler: (request: IncomingMessage, response: ServerResponse) => {
+        if (request.method !== 'POST') {
+          response.writeHead(405, { allow: 'POST' })
+          response.end()
+          return
+        }
+        // 进程控制：仅直接的同源回环请求；桌面模式下重启归壳层所有。
+        if (!trustedRestartRequest(request)) {
+          sendJson(response, 403, { error: 'untrusted origin' })
+          return
+        }
+        if (restartOwnedByShell()) {
+          sendJson(response, 409, { error: 'restart is owned by the desktop shell' })
+          return
+        }
+        const { pid, replacementPid, logOut } = scheduleRestart(dshLaunch())
+        sendJson(response, 200, { ok: true, pid, replacementPid, logOut })
+      },
+    }),
   ]
 
   return () => { for (const dispose of disposers) dispose() }