dsh-vscode-workbench 0.2.3 → 0.2.5

package/src/client/terminal.ts

@@ -1,100 +1,147 @@
-import type { TerminalInfo } from '../terminal.ts'
-import { ApiError, withSessionRetry } from './api.ts'
-import { websocketUrl } from './websocket.ts'
-
-export interface TerminalConnection {
-  write(data: string): void
-  resize(cols: number, rows: number): void
-  close(): void
-  subscribe(listener: (output: { sequence: number; data: string; replay?: boolean }) => void): () => void
-  subscribeError(listener: (message: string) => void): () => void
-}
+import type { ClientTerminals, TerminalView, TerminalViewState } from '@deepseek-ai/dsh-api-terminal-controller/client'
+import type { SessionId } from '@deepseek-ai/dsh-session/types'
 
-export interface TerminalWorkspaceSnapshot { terminals: readonly TerminalInfo[]; loading: boolean; error?: string }
-
-/** Browser client for the workbench's local terminal transport. */
-export interface TerminalWorkspace {
-  refresh(): Promise<boolean>
-  create(title?: string): Promise<TerminalInfo>
-  close(id: string): Promise<void>
-  rename(id: string, title: string): Promise<void>
-  connect(id: string): TerminalConnection
-  getSnapshot(): TerminalWorkspaceSnapshot
-  subscribe(listener: () => void): () => void
-}
+const STORAGE_PREFIX = 'dvw:native-terminal-tab:v1:'
+export interface TerminalEntry { id: string; title: string }
+export interface TerminalWorkspaceSnapshot { terminals: readonly TerminalEntry[]; loading: boolean; error?: string }
 
-async function request<T>(method: string, body: Record<string, unknown>): Promise<T> {
-  const response = await fetch(`/dsh-vscode-terminal/api/${method}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
-  const text = await response.text()
-  let answer: { ok?: boolean; value?: T; error?: { code?: string; message?: string } }
-  try { answer = JSON.parse(text) as { ok?: boolean; value?: T; error?: { code?: string; message?: string } } } catch { throw new Error(`terminal request returned invalid JSON (${response.status})`) }
-  if (!response.ok || answer.ok !== true) throw new ApiError(answer.error?.code ?? 'terminal-request-failed', answer.error?.message ?? 'terminal request failed')
-  return answer.value as T
-}
+/** Own workbench membership without overwriting the official sidebar's terminal inventory. */
+export class TerminalWorkspaces {
+  private readonly workspaces = new Map<string, TerminalWorkspaceController>()
+  private saved: Record<string, string[]> = Object.create(null)
+
+  constructor(readonly models: ClientTerminals) {
+    try {
+      this.saved = this.readSaved()
+    } catch { /* Invalid or unavailable storage must not prevent opening the terminal. */ }
+    this.retain()
+    window.addEventListener('storage', this.onStorage)
+  }
+
+  get(sessionId: string): TerminalWorkspaceController {
+    let workspace = this.workspaces.get(sessionId)
+    if (workspace === undefined) {
+      workspace = new TerminalWorkspaceController(this, sessionId, this.saved[sessionId] ?? [])
+      this.workspaces.set(sessionId, workspace)
+    }
+    return workspace
+  }
+
+  save(sessionId: string, ids: string[]): void {
+    const previous = this.saved[sessionId] ?? []
+    try {
+      // Independent records preserve concurrent additions from other windows and Sessions.
+      for (const id of ids) if (!previous.includes(id)) localStorage.setItem(STORAGE_PREFIX + JSON.stringify([sessionId, id]), 'open')
+      for (const id of previous) if (!ids.includes(id)) localStorage.removeItem(STORAGE_PREFIX + JSON.stringify([sessionId, id]))
+      this.sync(this.readSaved())
+    } catch { this.saved[sessionId] = ids; this.retain() }
+  }
 
-class SocketConnection implements TerminalConnection {
-  private readonly socket: WebSocket
-  private readonly listeners = new Set<(output: { sequence: number; data: string; replay?: boolean }) => void>()
-  private readonly errorListeners = new Set<(message: string) => void>()
-  private closed = false
-  private queue: string[] = []
-
-  constructor(sessionId: string, id: string) {
-    const url = websocketUrl(`/dsh-vscode-terminal/ws?sessionId=${encodeURIComponent(sessionId)}&id=${encodeURIComponent(id)}`)
-    if (url === undefined) throw new Error('无法连接终端：桌面端没有发布本地 Host 地址')
-    this.socket = new WebSocket(url)
-    this.socket.onopen = () => { for (const value of this.queue) this.socket.send(value); this.queue = [] }
-    this.socket.onerror = () => { for (const listener of this.errorListeners) listener('终端 WebSocket 连接失败') }
-    this.socket.onclose = () => { if (!this.closed) for (const listener of this.errorListeners) listener('终端 WebSocket 连接已断开') }
-    this.socket.onmessage = event => {
+  private readSaved(): Record<string, string[]> {
+    const saved: Record<string, string[]> = Object.create(null)
+    for (let index = 0; index < localStorage.length; index++) {
+      const key = localStorage.key(index)
+      if (!key?.startsWith(STORAGE_PREFIX)) continue
       try {
-        const value = JSON.parse(String(event.data)) as { type?: unknown; sequence?: unknown; data?: unknown }
-        if (typeof value.sequence !== 'number' || typeof value.data !== 'string') return
-        for (const listener of this.listeners) listener({ sequence: value.sequence, data: value.data, replay: value.type === 'replay' })
-      } catch { /* Ignore malformed WebSocket messages from a disconnected server. */ }
+        const value: unknown = JSON.parse(key.slice(STORAGE_PREFIX.length))
+        if (!Array.isArray(value) || value.length !== 2) continue
+        const [sessionId, id] = value
+        if (typeof sessionId !== 'string' || typeof id !== 'string' || !id.startsWith('dvw-terminal:')) continue
+        ;(saved[sessionId] ??= []).push(id)
+      } catch { /* Ignore only malformed external layout entries. */ }
     }
+    return saved
   }
 
-  private send(value: unknown): void { const text = JSON.stringify(value); if (this.socket.readyState === WebSocket.OPEN) this.socket.send(text); else this.queue.push(text) }
-  write(data: string): void { this.send({ type: 'input', data }) }
-  resize(cols: number, rows: number): void { this.send({ type: 'resize', cols, rows }) }
-  close(): void { this.closed = true; this.socket.close() }
-  subscribe(listener: (output: { sequence: number; data: string; replay?: boolean }) => void): () => void { this.listeners.add(listener); return () => this.listeners.delete(listener) }
-  subscribeError(listener: (message: string) => void): () => void { this.errorListeners.add(listener); return () => this.errorListeners.delete(listener) }
-}
+  private sync(saved: Record<string, string[]>): void {
+    this.saved = saved
+    for (const [sessionId, workspace] of this.workspaces) workspace.reconcile(saved[sessionId] ?? [])
+    this.retain()
+  }
+
+  private onStorage = (event: StorageEvent): void => {
+    if (event.storageArea !== localStorage || (event.key !== null && !event.key.startsWith(STORAGE_PREFIX))) return
+    this.sync(this.readSaved())
+  }
 
-/** Identify automatic terminal-emulator replies that must not be echoed during replay. */
-export function isTerminalProtocolReply(data: string): boolean {
-  return /^\x1b\](?:10|11|12);(?:rgb:[\da-f]{4}\/[\da-f]{4}\/[\da-f]{4}|#[\da-f]{6})(?:\x07|\x1b\\)$/i.test(data)
-    || /^\x1b\[\??[\d;]*[cR]$/.test(data)
+  private retain(): void {
+    this.models.retainTabs(Object.entries(this.saved).flatMap(([sessionId, ids]) => ids.map(id => ({ sessionId: sessionId as SessionId, tabId: id, contentId: id }))))
+  }
+
+  dispose(): void { window.removeEventListener('storage', this.onStorage); for (const workspace of this.workspaces.values()) workspace.dispose(); this.models.retainTabs([]) }
 }
 
-/** Maintain one terminal collection for a DSH session. */
-export class TerminalWorkspaceController implements TerminalWorkspace {
-  private snapshot: TerminalWorkspaceSnapshot = { terminals: [], loading: false }
+/** Layout only; the official model owns processes, stream ordering, recovery and input control. */
+export class TerminalWorkspaceController {
+  readonly closeFailures: ClientTerminals['closeFailures']
+  private snapshot: TerminalWorkspaceSnapshot
   private readonly listeners = new Set<() => void>()
+  private readonly views = new Map<string, { model: TerminalView; unsubscribe: () => void }>()
+
+  constructor(private readonly owner: TerminalWorkspaces, readonly sessionId: string, ids: readonly string[]) {
+    this.closeFailures = owner.models.closeFailures
+    this.snapshot = { terminals: ids.map(id => ({ id, title: '终端' })), loading: false }
+  }
 
-  constructor(private readonly sessionId: string) {}
+  view(id: string): TerminalView {
+    const existing = this.views.get(id)
+    if (existing !== undefined) return existing.model
+    const model = this.owner.models.view(this.sessionId as SessionId, id, id)
+    const unsubscribe = model.state.subscribe(() => this.updateTitles())
+    this.views.set(id, { model, unsubscribe })
+    this.updateTitles()
+    return model
+  }
 
   async refresh(): Promise<boolean> {
     this.set({ ...this.snapshot, loading: true, error: undefined })
     try {
-      this.set({ terminals: await withSessionRetry(() => request<TerminalInfo[]>('list', { sessionId: this.sessionId })), loading: false })
+      await Promise.all(this.snapshot.terminals.map(entry => this.view(entry.id).refresh()))
+      this.set({ ...this.snapshot, loading: false })
       return true
-    } catch (error) {
-      this.set({ ...this.snapshot, loading: false, error: error instanceof Error ? error.message : String(error) })
-      return false
-    }
+    } catch (error) { this.fail(error); return false }
+  }
+
+  async create(): Promise<TerminalEntry> {
+    const entry = { id: `dvw-terminal:${crypto.randomUUID()}`, title: '终端' }
+    this.set({ terminals: [...this.snapshot.terminals, entry], loading: false })
+    this.save()
+    const model = this.view(entry.id)
+    await model.refresh()
+    return this.snapshot.terminals.find(row => row.id === entry.id) ?? entry
   }
 
-  async create(title?: string): Promise<TerminalInfo> {
-    try { const terminal = await withSessionRetry(() => request<TerminalInfo>('create', { sessionId: this.sessionId, ...(title === undefined ? {} : { title }) })); await this.refresh(); return terminal }
-    catch (error) { this.set({ ...this.snapshot, loading: false, error: error instanceof Error ? error.message : String(error) }); throw error }
+  close(id: string): void {
+    this.owner.models.close(this.sessionId as SessionId, id, id)
+    this.views.get(id)?.unsubscribe()
+    this.views.delete(id)
+    this.set({ ...this.snapshot, terminals: this.snapshot.terminals.filter(entry => entry.id !== id) })
+    this.save()
   }
-  async close(id: string): Promise<void> { await withSessionRetry(() => request('close', { sessionId: this.sessionId, id })); await this.refresh() }
-  async rename(id: string, title: string): Promise<void> { await withSessionRetry(() => request('rename', { sessionId: this.sessionId, id, title })); await this.refresh() }
-  connect(id: string): TerminalConnection { return new SocketConnection(this.sessionId, id) }
-  getSnapshot(): TerminalWorkspaceSnapshot { return this.snapshot }
-  subscribe(listener: () => void): () => void { this.listeners.add(listener); return () => this.listeners.delete(listener) }
+
+  async rename(id: string, title: string): Promise<void> {
+    try { await this.view(id).rename(title) } catch (error) { this.fail(error) }
+  }
+  retryClose(id: Parameters<ClientTerminals['retryClose']>[0]): void { this.owner.models.retryClose(id) }
+
+  reconcile(ids: readonly string[]): void {
+    const entries = new Map(this.snapshot.terminals.map(entry => [entry.id, entry]))
+    for (const [id, view] of this.views) if (!ids.includes(id)) { view.unsubscribe(); this.views.delete(id) }
+    this.set({ ...this.snapshot, terminals: ids.map(id => entries.get(id) ?? { id, title: '终端' }) })
+  }
+
+  getSnapshot = (): TerminalWorkspaceSnapshot => this.snapshot
+  subscribe = (listener: () => void): (() => void) => { this.listeners.add(listener); return () => this.listeners.delete(listener) }
+  dispose(): void { for (const view of this.views.values()) view.unsubscribe(); this.views.clear() }
+  private save(): void { this.owner.save(this.sessionId, this.snapshot.terminals.map(entry => entry.id)) }
+  private updateTitles(): void {
+    this.set({ ...this.snapshot, terminals: this.snapshot.terminals.map(entry => ({ ...entry, title: this.views.get(entry.id)?.model.state.getSnapshot().title ?? entry.title })) })
+  }
+  private fail(error: unknown): void { this.set({ ...this.snapshot, loading: false, error: error instanceof Error ? error.message : String(error) }) }
   private set(snapshot: TerminalWorkspaceSnapshot): void { this.snapshot = snapshot; for (const listener of this.listeners) listener() }
 }
+
+export function terminalIssue(state: TerminalViewState): string | undefined {
+  const messages = { missingTerminal: '此终端已不存在，请关闭后新建终端。', inputFull: '终端输入缓冲已满，请重新连接。', attachmentEnded: '终端连接已结束，请重新连接。', invalidOutput: '终端输出无法解析，请重新连接。', terminalLimit: '终端数量已达上限，请关闭不用的终端。' }
+  return state.issue === undefined ? state.error ?? state.info?.error : messages[state.issue]
+}

package/src/index.ts

@@ -13,7 +13,6 @@ import { generateCommitMessage, normalizeCommitPreferences } from './commit-mess
 import { codiconAsset, createEntry, cwdFor, deleteEntry, fileIconAsset, gitAction, gitCommitContext, gitStatus, listFiles, monacoAsset, openWorkspaceFromPicker, pdfWorkerAsset, xlsxAsset, readDocument, projectSources, renameEntry, saveDocument, workspaceDownloadFile, searchWorkspace, uploadFile, workspacePreviewFile } from './host.ts'
 import { installLsp, lspStatuses, resolveLsp, uninstallLsp, pipeLanguageServer } from './lsp.ts'
 import { officePdf, officeStatus } from './office.ts'
-import { installTerminal } from './terminal.ts'
 import type { SearchRequest } from './types.ts'
 import { watchIgnore, workspaceWatchIgnores } from './watch-ignore.ts'
 import { readBinaryBody, readBody, send, sendError, stringField, authorize, WorkbenchError } from './wire.ts'
@@ -77,7 +76,6 @@ export function apply(ctx: HostContext): void {
     })
     return () => { void fiber.dispose?.() }
   }, 'dsh-vscode-workbench: optional DSH services')
-  installTerminal(ctx)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-vscode/codicons/codicon.ttf', handler: async (req, res) => {
       if (!authorize(req, res, ctx.connection)) return

package/src/lsp.ts

@@ -71,25 +71,33 @@ async function exists(path: string): Promise<boolean> { return access(path).then
  */
 export function lspSearchDirs(env: NodeJS.ProcessEnv = process.env, home = homedir()): string[] {
   const fromPath = (env.PATH ?? env.Path ?? '').split(delimiter).filter(Boolean)
-  const extras = [
-    join(home, 'go', 'bin'),
-    join(home, '.cargo', 'bin'),
-    join(home, '.dotnet', 'tools'),
-    join(home, '.local', 'bin'),
-    join(home, 'bin'),
-    '/opt/homebrew/bin',
-    '/usr/local/bin',
-    '/usr/bin',
-    '/bin',
-    '/usr/sbin',
-    '/sbin',
-  ]
+  const extras = process.platform === 'win32'
+    ? [
+      join(home, 'go', 'bin'),
+      join(home, '.cargo', 'bin'),
+      join(home, '.dotnet', 'tools'),
+      join(home, 'bin'),
+    ]
+    : [
+      join(home, 'go', 'bin'),
+      join(home, '.cargo', 'bin'),
+      join(home, '.dotnet', 'tools'),
+      join(home, '.local', 'bin'),
+      join(home, 'bin'),
+      '/opt/homebrew/bin',
+      '/usr/local/bin',
+      '/usr/bin',
+      '/bin',
+      '/usr/sbin',
+      '/sbin',
+    ]
   return [...new Set([...fromPath, ...extras])]
 }
 
 async function executableIn(directory: string, command: string): Promise<string | undefined> {
+  // Windows has no executable bit: access(X_OK) accepts any file, so only accept real command extensions.
   const names = process.platform === 'win32'
-    ? [`${command}.exe`, `${command}.cmd`, `${command}.bat`, command]
+    ? [`${command}.exe`, `${command}.cmd`, `${command}.bat`, `${command}.com`]
     : [command]
   for (const name of names) {
     const file = join(directory, name)

package/lib/types/terminal.d.ts

@@ -1,46 +0,0 @@
-import type { IPty } from 'node-pty';
-import type { HostContext } from './context.ts';
-export interface TerminalInfo {
-    id: string;
-    title: string;
-    cwd: string;
-    running: boolean;
-    exitCode?: number;
-    sequence: number;
-}
-export interface TerminalOutput {
-    sequence: number;
-    data: string;
-}
-interface TerminalHandle {
-    info: TerminalInfo;
-    process: IPty;
-    replay: string;
-    listeners: Set<(output: TerminalOutput) => void>;
-}
-/** Remove credentials while retaining ordinary interactive-shell variables. */
-export declare function sanitizedTerminalEnv(env: NodeJS.ProcessEnv): Record<string, string>;
-/** Select the user's interactive shell with platform-specific fallbacks. */
-export declare function defaultTerminalShell(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv): {
-    shell: string;
-    args: string[];
-};
-/** Add execute bits when a registry package extracted a native helper without them. */
-export declare function ensureExecutable(path: string): boolean;
-/** Repair node-pty's macOS/Linux helper, whose npm package currently loses its execute bit. */
-export declare function repairNodePtyHelper(): void;
-/** Own interactive terminals by their canonical workspace directory. */
-export declare class TerminalManager {
-    private readonly workspaces;
-    constructor();
-    private workspace;
-    list(cwd: string): TerminalInfo[];
-    create(cwd: string, title?: string): TerminalInfo;
-    get(cwd: string, id: string): TerminalHandle | undefined;
-    close(cwd: string, id: string): void;
-    rename(cwd: string, id: string, title: string): TerminalInfo;
-    dispose(): void;
-}
-/** Register the private local terminal API and WebSocket transport. */
-export declare function installTerminal(ctx: HostContext): void;
-export {};

package/src/terminal.ts

@@ -1,173 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import { chmodSync, realpathSync, statSync } from 'node:fs'
-import { createRequire } from 'node:module'
-import { basename, dirname, join } from 'node:path'
-import type { IncomingMessage } from 'node:http'
-import type { Duplex } from 'node:stream'
-import * as pty from 'node-pty'
-import type { IPty } from 'node-pty'
-import { WebSocket, WebSocketServer } from 'ws'
-import type { HostContext } from './context.ts'
-import { cwdFor } from './host.ts'
-import { authorize, readBody, send, sendError } from './wire.ts'
-
-const require = createRequire(import.meta.url)
-
-export interface TerminalInfo { id: string; title: string; cwd: string; running: boolean; exitCode?: number; sequence: number }
-export interface TerminalOutput { sequence: number; data: string }
-
-interface TerminalHandle { info: TerminalInfo; process: IPty; replay: string; listeners: Set<(output: TerminalOutput) => void> }
-const SENSITIVE = /(api[_-]?key|token|credential|secret|password|passwd|private[_-]?key|^dsh_.*(?:key|token|secret))/i
-const MAX_TERMINALS = 8
-const REPLAY_BYTES = 2 * 1024 * 1024
-
-/** Remove credentials while retaining ordinary interactive-shell variables. */
-export function sanitizedTerminalEnv(env: NodeJS.ProcessEnv): Record<string, string> {
-  return Object.fromEntries(Object.entries(env).filter(([key, value]) => value !== undefined && !SENSITIVE.test(key)) as Array<[string, string]>)
-}
-
-/** Select the user's interactive shell with platform-specific fallbacks. */
-export function defaultTerminalShell(platform = process.platform, env = process.env): { shell: string; args: string[] } {
-  if (platform === 'win32') return { shell: env.COMSPEC?.toLowerCase().includes('powershell') ? env.COMSPEC : 'powershell.exe', args: ['-NoLogo'] }
-  return { shell: env.SHELL || (platform === 'darwin' ? '/bin/zsh' : '/bin/bash'), args: ['-l'] }
-}
-
-/** Add execute bits when a registry package extracted a native helper without them. */
-export function ensureExecutable(path: string): boolean {
-  if (process.platform === 'win32') return true
-  try {
-    const mode = statSync(path).mode
-    if ((mode & 0o111) === 0) chmodSync(path, mode | 0o111)
-    return true
-  } catch {
-    return false
-  }
-}
-
-/** Repair node-pty's macOS/Linux helper, whose npm package currently loses its execute bit. */
-export function repairNodePtyHelper(): void {
-  if (process.platform === 'win32') return
-  const packageDirectory = dirname(require.resolve('node-pty/package.json'))
-  ensureExecutable(join(packageDirectory, 'build', 'Release', 'spawn-helper'))
-  ensureExecutable(join(packageDirectory, 'prebuilds', `${process.platform}-${process.arch}`, 'spawn-helper'))
-}
-
-/** Own interactive terminals by their canonical workspace directory. */
-export class TerminalManager {
-  private readonly workspaces = new Map<string, Map<string, TerminalHandle>>()
-
-  constructor() { repairNodePtyHelper() }
-
-  private workspace(cwd: string): string { return realpathSync(cwd) }
-
-  list(cwd: string): TerminalInfo[] { return [...(this.workspaces.get(this.workspace(cwd))?.values() ?? [])].map(handle => ({ ...handle.info })) }
-
-  create(cwd: string, title?: string): TerminalInfo {
-    const key = this.workspace(cwd)
-    const terminals = this.workspaces.get(key) ?? new Map<string, TerminalHandle>()
-    this.workspaces.set(key, terminals)
-    if (terminals.size >= MAX_TERMINALS) throw new Error(`terminal limit reached (${MAX_TERMINALS})`)
-    const { shell, args } = defaultTerminalShell()
-    const child = pty.spawn(shell, args, { name: 'xterm-256color', cols: 80, rows: 24, cwd: key, env: sanitizedTerminalEnv(process.env) })
-    const info: TerminalInfo = { id: randomUUID(), title: title || basename(shell), cwd: key, running: true, sequence: 0 }
-    const handle: TerminalHandle = { info, process: child, replay: '', listeners: new Set() }
-    terminals.set(info.id, handle)
-    child.onData(data => {
-      info.sequence++
-      handle.replay += data
-      if (Buffer.byteLength(handle.replay) > REPLAY_BYTES) handle.replay = handle.replay.slice(-REPLAY_BYTES)
-      for (const listener of handle.listeners) listener({ sequence: info.sequence, data })
-    })
-    child.onExit(({ exitCode }) => {
-      info.running = false
-      info.exitCode = exitCode
-      info.sequence++
-      const data = `\r\n[process exited with code ${exitCode}]\r\n`
-      for (const listener of handle.listeners) listener({ sequence: info.sequence, data })
-    })
-    return { ...info }
-  }
-
-  get(cwd: string, id: string): TerminalHandle | undefined { return this.workspaces.get(this.workspace(cwd))?.get(id) }
-
-  close(cwd: string, id: string): void {
-    const key = this.workspace(cwd)
-    const terminals = this.workspaces.get(key)
-    const handle = terminals?.get(id)
-    if (handle === undefined || terminals === undefined) return
-    terminals.delete(id)
-    try { handle.process.kill() } catch { /* The shell may already have exited. */ }
-    if (terminals.size === 0) this.workspaces.delete(key)
-  }
-
-  rename(cwd: string, id: string, title: string): TerminalInfo {
-    const handle = this.get(cwd, id)
-    if (handle === undefined) throw new Error('terminal not found')
-    handle.info.title = title
-    return { ...handle.info }
-  }
-
-  dispose(): void { for (const [cwd, terminals] of this.workspaces) for (const id of terminals.keys()) this.close(cwd, id) }
-}
-
-function terminalRequestAllowed(req: IncomingMessage): boolean {
-  const host = req.headers.host
-  if (host === undefined || req.headers['sec-fetch-site'] === 'cross-site') return false
-  let hostname: string
-  try { hostname = new URL(`http://${host}`).hostname } catch { return false }
-  if (hostname !== 'localhost' && hostname !== '[::1]' && !hostname.startsWith('127.')) return false
-  const origin = req.headers.origin
-  try { return origin === undefined || new URL(origin).host === host } catch { return false }
-}
-
-/** Register the private local terminal API and WebSocket transport. */
-export function installTerminal(ctx: HostContext): void {
-  const manager = new TerminalManager()
-  ctx.effect(() => ctx.webServer.register({ kind: 'prefix', path: '/dsh-vscode-terminal/api', handler: async (req, res) => {
-    if (!authorize(req, res, ctx.connection)) return
-    if (!terminalRequestAllowed(req)) return send(res, 403, { ok: false, error: { message: 'forbidden' } })
-    if (req.method !== 'POST') return send(res, 405, { ok: false, error: { message: 'POST required' } })
-    try {
-      const body = await readBody(req)
-      const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
-      if (sessionId === '') throw new Error('sessionId required')
-      const cwd = cwdFor(ctx, sessionId)
-      const method = new URL(req.url ?? '/', 'http://dsh.local').pathname.slice('/dsh-vscode-terminal/api/'.length)
-      let value: unknown
-      if (method === 'list') value = manager.list(cwd)
-      else if (method === 'create') value = manager.create(cwd, typeof body.title === 'string' ? body.title : undefined)
-      else if (method === 'close') { manager.close(cwd, typeof body.id === 'string' ? body.id : ''); value = manager.list(cwd) }
-      else if (method === 'rename') value = manager.rename(cwd, typeof body.id === 'string' ? body.id : '', typeof body.title === 'string' ? body.title : '')
-      else throw new Error('unknown terminal method')
-      send(res, 200, { ok: true, value })
-    } catch (error) { sendError(res, error) }
-  } }), 'dsh-vscode-workbench: terminal API')
-
-  const webSocket = new WebSocketServer({ noServer: true })
-  ctx.effect(() => ctx.webServer.registerUpgrade({ path: '/dsh-vscode-terminal/ws', handler(req, socket, head) {
-    if (ctx.connection.requestRejection(req) !== undefined || !terminalRequestAllowed(req)) { socket.destroy(); return }
-    webSocket.handleUpgrade(req as IncomingMessage, socket as Duplex, head, connection => {
-      const url = new URL(req.url ?? '/', 'http://dsh.local')
-      const sessionId = url.searchParams.get('sessionId')
-      const id = url.searchParams.get('id')
-      if (sessionId === null || id === null) { connection.close(1008, 'sessionId and id required'); return }
-      let handle: TerminalHandle | undefined
-      try { handle = manager.get(cwdFor(ctx, sessionId), id) }
-      catch { connection.close(1008, 'session workspace unavailable'); return }
-      if (handle === undefined) { connection.close(1008, 'terminal not found'); return }
-      if (handle.replay !== '') connection.send(JSON.stringify({ type: 'replay', sequence: handle.info.sequence, data: handle.replay }))
-      const listener = (output: TerminalOutput) => { if (connection.readyState === WebSocket.OPEN) connection.send(JSON.stringify({ type: 'output', ...output })) }
-      handle.listeners.add(listener)
-      connection.on('message', raw => {
-        const text = raw.toString()
-        try {
-          const message: unknown = JSON.parse(text)
-          if (message !== null && typeof message === 'object' && 'type' in message && message.type === 'input' && 'data' in message && typeof message.data === 'string') handle.process.write(message.data)
-          else if (message !== null && typeof message === 'object' && 'type' in message && message.type === 'resize' && 'cols' in message && 'rows' in message && typeof message.cols === 'number' && typeof message.rows === 'number') handle.process.resize(Math.max(2, Math.floor(message.cols)), Math.max(2, Math.floor(message.rows)))
-        } catch { handle.process.write(text) }
-      })
-      connection.on('close', () => handle.listeners.delete(listener))
-    })
-  } }), 'dsh-vscode-workbench: terminal WebSocket')
-  ctx.effect(() => () => { webSocket.close(); manager.dispose() }, 'dsh-vscode-workbench: terminal teardown')
-}