dsh-vscode-workbench 0.1.7 → 0.1.9

package/src/client/terminal.ts

@@ -0,0 +1,83 @@
+import type { TerminalInfo } from '../terminal.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
+}
+
+export interface TerminalWorkspaceSnapshot { terminals: readonly TerminalInfo[]; loading: boolean; error?: string }
+
+/** Browser client for the workbench's local terminal transport. */
+export interface TerminalWorkspace {
+  refresh(): Promise<void>
+  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
+}
+
+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?: { message?: string } }
+  try { answer = JSON.parse(text) as { ok?: boolean; value?: T; error?: { message?: string } } } catch { throw new Error(`terminal request returned invalid JSON (${response.status})`) }
+  if (!response.ok || answer.ok !== true) throw new Error(answer.error?.message ?? 'terminal request failed')
+  return answer.value as T
+}
+
+class SocketConnection implements TerminalConnection {
+  private readonly socket: WebSocket
+  private readonly listeners = new Set<(output: { sequence: number; data: string; replay?: boolean }) => void>()
+  private queue: string[] = []
+
+  constructor(sessionId: string, id: string) {
+    const protocol = location.protocol === 'https:' ? 'wss' : 'ws'
+    this.socket = new WebSocket(`${protocol}://${location.host}/dsh-vscode-terminal/ws?sessionId=${encodeURIComponent(sessionId)}&id=${encodeURIComponent(id)}`)
+    this.socket.onopen = () => { for (const value of this.queue) this.socket.send(value); this.queue = [] }
+    this.socket.onmessage = event => {
+      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. */ }
+    }
+  }
+
+  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.socket.close() }
+  subscribe(listener: (output: { sequence: number; data: string; replay?: boolean }) => void): () => void { this.listeners.add(listener); return () => this.listeners.delete(listener) }
+}
+
+/** 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)
+}
+
+/** Maintain one terminal collection for a DSH session. */
+export class TerminalWorkspaceController implements TerminalWorkspace {
+  private snapshot: TerminalWorkspaceSnapshot = { terminals: [], loading: false }
+  private readonly listeners = new Set<() => void>()
+
+  constructor(private readonly sessionId: string) {}
+
+  async refresh(): Promise<void> {
+    this.set({ ...this.snapshot, loading: true, error: undefined })
+    try { this.set({ terminals: await request<TerminalInfo[]>('list', { sessionId: this.sessionId }), loading: false }) }
+    catch (error) { this.set({ ...this.snapshot, loading: false, error: error instanceof Error ? error.message : String(error) }) }
+  }
+
+  async create(title?: string): Promise<TerminalInfo> { const terminal = await request<TerminalInfo>('create', { sessionId: this.sessionId, ...(title === undefined ? {} : { title }) }); await this.refresh(); return terminal }
+  async close(id: string): Promise<void> { await request('close', { sessionId: this.sessionId, id }); await this.refresh() }
+  async rename(id: string, title: string): Promise<void> { await 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) }
+  private set(snapshot: TerminalWorkspaceSnapshot): void { this.snapshot = snapshot; for (const listener of this.listeners) listener() }
+}

package/src/context.ts

@@ -1,16 +1,18 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
 import type { Duplex } from 'node:stream'
 import type { Context as CordisContext } from '@deepseek-ai/cordis'
+import type { Session } from '@deepseek-ai/dsh-session'
 
 export interface WorkbenchWebServer {
   register(route: { kind: 'exact' | 'prefix'; path: string; handler(req: IncomingMessage, res: ServerResponse): void | Promise<void> }): () => void
   registerUpgrade(route: { path: string; handler(req: IncomingMessage, socket: Duplex, head: Buffer): void | Promise<void> }): () => void
 }
-export interface WorkbenchSessions { get(id: string): { header: { cwd?: string } } | undefined }
-export interface WorkbenchWebRuntime { trustedHosts: readonly string[] }
+export interface WorkbenchSessions { get(id: string): Session | undefined }
+export interface WorkbenchConnection { requestRejection(req: IncomingMessage): 401 | 403 | undefined }
 export type HostContext = CordisContext & {
   webServer: WorkbenchWebServer
   sessions: WorkbenchSessions
-  webRuntime: WorkbenchWebRuntime
+  connection: WorkbenchConnection
+  workingDirectory: { get(session: Session): string }
   effect(callback: () => void | (() => void), label?: string): void
 }

package/src/host.ts

@@ -13,8 +13,9 @@ const TEXT_LIMIT = 5 * 1024 * 1024
 const PROCESS_TIMEOUT = 30_000
 
 export function cwdFor(ctx: HostContext, sessionId: string): string {
-  const cwd = ctx.sessions.get(sessionId)?.header.cwd
-  if (cwd === undefined || cwd === '') return process.cwd()
+  const session = ctx.sessions.get(sessionId)
+  if (session === undefined) throw new WorkbenchError('session-not-found', 'session not found', 404)
+  const cwd = ctx.workingDirectory.get(session)
   if (!isAbsolute(cwd)) throw new WorkbenchError('cwd-invalid', 'session working directory is not absolute')
   return normalize(cwd)
 }
@@ -125,8 +126,16 @@ export async function deleteEntry(cwd: string, path: string): Promise<void> {
 }
 
 const IMAGE_TYPES:Record<string,string>={'.avif':'image/avif','.bmp':'image/bmp','.gif':'image/gif','.ico':'image/x-icon','.jpeg':'image/jpeg','.jpg':'image/jpeg','.png':'image/png','.svg':'image/svg+xml','.webp':'image/webp'}
+const PREVIEW_TYPES:Record<string,string>={...IMAGE_TYPES,'.pdf':'application/pdf','.doc':'application/msword','.docx':'application/vnd.openxmlformats-officedocument.wordprocessingml.document','.odt':'application/vnd.oasis.opendocument.text'}
 /** Resolve an image inside the workspace for protected browser preview. */
 export async function workspaceImage(cwd:string,path:string):Promise<{path:string;type:string}>{const resolved=await workspacePath(cwd,path);const type=IMAGE_TYPES[extname(resolved.absolute).toLowerCase()];if(type===undefined)throw new WorkbenchError('unsupported-media','file is not a supported image',415);return {path:resolved.absolute,type}}
+/** Resolve a supported preview file inside the workspace. */
+export async function workspacePreviewFile(cwd:string,path:string):Promise<{path:string;type:string}>{const resolved=await workspacePath(cwd,path);const type=PREVIEW_TYPES[extname(resolved.absolute).toLowerCase()];if(type===undefined)throw new WorkbenchError('unsupported-media','file is not a supported preview format',415);return {path:resolved.absolute,type}}
+
+/** Resolve the PDF.js worker shipped with this plugin's runtime dependency. */
+export function pdfWorkerAsset(): { path: string; type: string } {
+  return { path: require.resolve('pdfjs-dist/legacy/build/pdf.worker.min.mjs'), type: 'text/javascript; charset=utf-8' }
+}
 
 interface ProcessResult { stdout: string; stderr: string; code: number }
 export function run(command: string, args: string[], cwd: string, timeout = PROCESS_TIMEOUT, signal?: AbortSignal): Promise<ProcessResult> {

package/src/index.ts

@@ -6,14 +6,15 @@ import type { Duplex } from 'node:stream'
 import chokidar from 'chokidar'
 import { WebSocket, WebSocketServer } from 'ws'
 import type { HostContext } from './context.ts'
-import { codiconAsset, createEntry, cwdFor, deleteEntry, gitAction, gitStatus, listFiles, monacoAsset, readDocument, renameEntry, saveDocument, searchWorkspace, uploadFile, workspaceImage } from './host.ts'
+import { codiconAsset, createEntry, cwdFor, deleteEntry, gitAction, gitStatus, listFiles, monacoAsset, pdfWorkerAsset, readDocument, renameEntry, saveDocument, searchWorkspace, uploadFile, workspacePreviewFile } from './host.ts'
+import { installTerminal } from './terminal.ts'
 import type { SearchRequest } from './types.ts'
-import { readBinaryBody, readBody, send, sendError, stringField, trusted, WorkbenchError } from './wire.ts'
+import { readBinaryBody, readBody, send, sendError, stringField, authorize, WorkbenchError } from './wire.ts'
 
 export { WorkbenchError } from './wire.ts'
 export * from './types.ts'
 export const name = 'dsh-vscode-workbench'
-export const inject = ['webServer', 'sessions', 'webRuntime']
+export const inject = ['webServer', 'sessions', 'connection', 'workingDirectory']
 
 async function dispatch(ctx: HostContext, method: string, body: Record<string, unknown>, signal?: AbortSignal): Promise<unknown> {
   const sessionId = stringField(body, 'sessionId'); const cwd = cwdFor(ctx, sessionId)
@@ -33,9 +34,10 @@ async function dispatch(ctx: HostContext, method: string, body: Record<string, u
 }
 
 export function apply(ctx: HostContext): void {
+  installTerminal(ctx)
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-vscode/codicons/codicon.ttf', handler: async (req, res) => {
-      if (!trusted(req, ctx.webRuntime.trustedHosts)) { res.writeHead(403); res.end(); return }
+      if (!authorize(req, res, ctx.connection)) return
       try {
         const asset = codiconAsset()
         res.writeHead(200, { 'content-type': asset.type, 'cache-control': 'public, max-age=31536000, immutable' })
@@ -44,9 +46,20 @@ export function apply(ctx: HostContext): void {
     },
   }), 'dsh-vscode-workbench: Codicon font')
 
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact', path: '/dsh-vscode/pdfjs/worker.mjs', handler: async (req, res) => {
+      if (!authorize(req, res, ctx.connection)) return
+      try {
+        const asset = pdfWorkerAsset()
+        res.writeHead(200, { 'content-type': asset.type, 'cache-control': 'public, max-age=31536000, immutable' })
+        res.end(await readFile(asset.path))
+      } catch (error) { sendError(res, error) }
+    },
+  }), 'dsh-vscode-workbench: PDF.js worker')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix', path: '/dsh-vscode/api', handler: async (req, res) => {
-      if (!trusted(req, ctx.webRuntime.trustedHosts)) return send(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } })
+      if (!authorize(req, res, ctx.connection)) return
       if (req.method !== 'POST') return send(res, 405, { ok: false, error: { code: 'method', message: 'POST required' } })
       try {
         const controller = new AbortController()
@@ -60,7 +73,7 @@ export function apply(ctx: HostContext): void {
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact', path: '/dsh-vscode/upload', handler: async (req, res) => {
-      if (!trusted(req, ctx.webRuntime.trustedHosts)) return send(res, 403, { ok: false, error: { code: 'forbidden', message: 'forbidden' } })
+      if (!authorize(req, res, ctx.connection)) return
       if (req.method !== 'POST') return send(res, 405, { ok: false, error: { code: 'method', message: 'POST required' } })
       try {
         const url = new URL(req.url ?? '/', 'http://dsh.local')
@@ -72,12 +85,12 @@ export function apply(ctx: HostContext): void {
   }), 'dsh-vscode-workbench: file upload')
 
   ctx.effect(() => ctx.webServer.register({
-    kind:'prefix',path:'/dsh-vscode/file',handler:async(req,res)=>{if(!trusted(req,ctx.webRuntime.trustedHosts)){res.writeHead(403);res.end();return}try{const url=new URL(req.url??'/','http://dsh.local');const sessionId=url.searchParams.get('sessionId');const path=url.searchParams.get('path');if(sessionId===null||path===null)throw new WorkbenchError('bad-request','sessionId and path are required');const asset=await workspaceImage(cwdFor(ctx,sessionId),path);res.writeHead(200,{'content-type':asset.type,'x-content-type-options':'nosniff','cache-control':'no-store'});res.end(await readFile(asset.path))}catch(error){sendError(res,error)}}
-  }), 'dsh-vscode-workbench: image preview')
+    kind:'prefix',path:'/dsh-vscode/file',handler:async(req,res)=>{if(!authorize(req,res,ctx.connection))return;try{const url=new URL(req.url??'/','http://dsh.local');const sessionId=url.searchParams.get('sessionId');const path=url.searchParams.get('path');if(sessionId===null||path===null)throw new WorkbenchError('bad-request','sessionId and path are required');const asset=await workspacePreviewFile(cwdFor(ctx,sessionId),path);res.writeHead(200,{'content-type':asset.type,'x-content-type-options':'nosniff','cache-control':'no-store'});res.end(await readFile(asset.path))}catch(error){sendError(res,error)}}
+  }), 'dsh-vscode-workbench: file preview')
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'prefix', path: '/dsh-vscode/monaco', handler: async (req, res) => {
-      if (!trusted(req, ctx.webRuntime.trustedHosts)) { res.writeHead(403); res.end(); return }
+      if (!authorize(req, res, ctx.connection)) return
       try {
         const raw = decodeURIComponent(new URL(req.url ?? '/', 'http://dsh.local').pathname.slice('/dsh-vscode/monaco/'.length))
         const asset = monacoAsset(raw)
@@ -90,11 +103,13 @@ export function apply(ctx: HostContext): void {
   const wss = new WebSocketServer({ noServer: true })
   ctx.effect(() => ctx.webServer.registerUpgrade({
     path: '/dsh-vscode/ws/files', handler(req, socket, head) {
-      if (!trusted(req as IncomingMessage, ctx.webRuntime.trustedHosts)) { socket.destroy(); return }
+      if (ctx.connection.requestRejection(req) !== undefined) { socket.destroy(); return }
       wss.handleUpgrade(req as IncomingMessage, socket as Duplex, head, (ws) => {
         const sessionId = new URL(req.url ?? '/', 'http://dsh.local').searchParams.get('sessionId')
         if (sessionId === null) { ws.close(1008, 'sessionId required'); return }
-        const workspace = cwdFor(ctx, sessionId)
+        let workspace: string
+        try { workspace = cwdFor(ctx, sessionId) }
+        catch { ws.close(1008, 'session workspace unavailable'); return }
         const watcher = chokidar.watch(workspace, { ignoreInitial: true, ignored: /(^|[/\\])(\.git|node_modules|\.next|\.nuxt|\.turbo|\.vite|coverage)([/\\]|$)/, awaitWriteFinish: { stabilityThreshold: 100, pollInterval: 25 } })
         let paths = new Set<string>(); let timer: ReturnType<typeof setTimeout> | undefined
         watcher.on('all', (_event, path) => {

package/src/terminal.ts

@@ -0,0 +1,148 @@
+import { randomUUID } from 'node:crypto'
+import { realpathSync } from 'node:fs'
+import { basename } 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'
+
+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'] }
+}
+
+/** Own interactive terminals by their canonical workspace directory. */
+export class TerminalManager {
+  private readonly workspaces = new Map<string, Map<string, TerminalHandle>>()
+
+  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')
+}

package/src/wire.ts

@@ -1,4 +1,5 @@
 import type { IncomingMessage, ServerResponse } from 'node:http'
+import type { WorkbenchConnection } from './context.ts'
 
 export class WorkbenchError extends Error {
   constructor(public code: string, message: string, public status = 400) { super(message) }
@@ -49,14 +50,11 @@ export function sendError(res: ServerResponse, error: unknown): void {
   send(res, known.status, { ok: false, error: { code: known.code, message: known.message } })
 }
 
-export function trusted(req: IncomingMessage, allowed: readonly string[]): boolean {
-  const host = req.headers.host
-  if (host === undefined || req.headers['sec-fetch-site'] === 'cross-site') return false
-  let hostUrl: URL
-  try { hostUrl = new URL(`http://${host}`) } catch { return false }
-  const loopback = hostUrl.hostname === 'localhost' || hostUrl.hostname === '[::1]' || /^127(?:\.\d{1,3}){3}$/.test(hostUrl.hostname)
-  if (!loopback && !allowed.some(candidate => candidate === host || candidate === hostUrl.hostname)) return false
-  const origin = req.headers.origin
-  if (origin === undefined) return true
-  try { return new URL(origin).host === hostUrl.host } catch { return false }
+/** Reuse Harness authentication and its deployment-aware Host/Origin fence. */
+export function authorize(req: IncomingMessage, res: ServerResponse, connection: WorkbenchConnection): boolean {
+  const rejection = connection.requestRejection(req)
+  if (rejection === undefined) return true
+  const code = rejection === 401 ? 'unauthorized' : 'forbidden'
+  send(res, rejection, { ok: false, error: { code, message: code } })
+  return false
 }