@lincyaw/dsh 0.1.0 → 0.2.0-rc.0

package/src/node/fake-model.ts

@@ -0,0 +1,80 @@
+import { createServer } from 'node:http'
+import type { IncomingHttpHeaders } from 'node:http'
+import type { AddressInfo } from 'node:net'
+
+export type Step = { text: string } | { tool: string, input: Record<string, unknown> }
+
+export interface Received {
+  path: string
+  headers: IncomingHttpHeaders
+  body: Record<string, any>
+}
+
+export interface FakeModel {
+  url: string
+  received: Received[]
+  hold(): void
+  release(): void
+  close(): Promise<void>
+}
+
+const event = (name: string, data: unknown) => `event: ${name}\ndata: ${JSON.stringify(data)}\n\n`
+
+function stream(step: Step, n: number): string {
+  const start = { type: 'message_start', message: { id: `msg_${n}`, type: 'message', role: 'assistant', model: 'fake-model', content: [], stop_reason: null, stop_sequence: null, usage: { input_tokens: 10, output_tokens: 0 } } }
+  const block = 'text' in step
+    ? [event('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'text', text: '' } }), event('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'text_delta', text: step.text } })]
+    : [event('content_block_start', { type: 'content_block_start', index: 0, content_block: { type: 'tool_use', id: `toolu_${n}`, name: step.tool, input: {} } }), event('content_block_delta', { type: 'content_block_delta', index: 0, delta: { type: 'input_json_delta', partial_json: JSON.stringify(step.input) } })]
+  return [
+    event('message_start', start),
+    ...block,
+    event('content_block_stop', { type: 'content_block_stop', index: 0 }),
+    event('message_delta', { type: 'message_delta', delta: { stop_reason: 'text' in step ? 'end_turn' : 'tool_use', stop_sequence: null }, usage: { output_tokens: 5 } }),
+    event('message_stop', { type: 'message_stop' }),
+  ].join('')
+}
+
+export async function fakeModel(script: Step[]): Promise<FakeModel> {
+  const received: Received[] = []
+  let held: Promise<void> | undefined
+  let release = () => {}
+  const server = createServer((req, res) => {
+    let body = ''
+    req.setEncoding('utf8').on('data', (chunk: string) => body += chunk)
+    req.on('end', async () => {
+      let parsed: Record<string, any> = {}
+      try {
+        parsed = JSON.parse(body) as Record<string, any>
+      } catch {
+      }
+      const record: Received = { path: req.url ?? '', headers: req.headers, body: parsed }
+      received.push(record)
+      if (req.method !== 'POST' || !(req.url ?? '').endsWith('/v1/messages')) {
+        res.writeHead(404).end()
+        return
+      }
+      await held
+      const turn = (r: Received) => r.path.endsWith('/v1/messages') && Array.isArray(r.body.tools) && r.body.tools.length > 0
+      const n = received.filter(r => r.path.endsWith('/v1/messages')).length
+      const step = turn(record) ? script[received.filter(turn).indexOf(record)] ?? { text: '完毕。' } : { text: 'Presmium' }
+      res.writeHead(200, { 'Content-Type': 'text/event-stream' }).end(stream(step, n))
+    })
+  })
+  const port = await new Promise<number>(done => server.listen(0, '127.0.0.1', () => done((server.address() as AddressInfo).port)))
+  return {
+    url: `http://127.0.0.1:${port}`,
+    received,
+    hold() {
+      held = new Promise(done => release = done)
+    },
+    release() {
+      release()
+      held = undefined
+    },
+    close: () => new Promise<void>((done) => {
+      release()
+      server.close(() => done())
+      server.closeAllConnections()
+    }),
+  }
+}

package/src/node/launch.ts

@@ -1,12 +1,19 @@
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
 import { createRequire } from 'node:module'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
+import { machineState, NODE_RESOURCE_ARGS, nodeResourceArgs, resourceEnvironment } from '@lincyaw/kernel/node'
+export { bracketIPv6, systemLocale } from '@lincyaw/kernel/node'
 
 export type Carrier = 'web' | 'headless' | 'acp'
 
-export const PACKAGE_DIR = fileURLToPath(new URL('../..', import.meta.url))
-export const PACKAGE_NAME = '@lincyaw/dsh'
+const PACKAGE_DIR = fileURLToPath(new URL('../..', import.meta.url))
+const PACKAGE_NAME = '@lincyaw/dsh'
+const WATCHDOG = join(PACKAGE_DIR, 'src', 'node', 'watchdog.mjs')
+const READY_MS = 180_000
+const STOP_MS = 15_000
 
 const CARRIERS: Record<Carrier, string> = {
   web: '@deepseek-ai/dsh-web-app',
@@ -22,13 +29,10 @@ export function launchArgs(name: string, carrier: Carrier): string[] {
   return ['--profile', name, ...launchPatches(carrier).flatMap(file => ['--patch', file])]
 }
 
-export const WATCHDOG = join(PACKAGE_DIR, 'src', 'node', 'watchdog.mjs')
-
 export const WEB_READY = /^dsh web: (https?:\/\/\S+)$/m
-
-export function dshVersion(): string {
-  return (JSON.parse(readFileSync(join(PACKAGE_DIR, 'package.json'), 'utf8')) as { engines: { dsh: string } }).engines.dsh
-}
+/** The two lines `presmium serve` prints when it is ready: its address and the workspace root. */
+export const SERVE_READY = /^serve {2}(http\S+)$/m
+export const WORKSPACE_READY = /^workspace {2}(.+)$/m
 
 export function dshBin(from = PACKAGE_DIR): string {
   const manifest = createRequire(join(from, 'package.json')).resolve('@deepseek-ai/dsh/package.json')
@@ -36,8 +40,121 @@ export function dshBin(from = PACKAGE_DIR): string {
   return join(dirname(manifest), typeof bin === 'string' ? bin : bin.dsh!)
 }
 
-export function launchEnv(dshHome: string): Record<string, string> {
-  return { DSH_HOME: dshHome, DSH_AGENTS_HOME: join(dshHome, 'agents'), DSH_TELEMETRY_MODE: 'DISABLED' }
+export function launchEnv(dshHome: string, env: NodeJS.ProcessEnv = process.env): Record<string, string> {
+  return resourceEnvironment({ DSH_HOME: dshHome, DSH_AGENTS_HOME: join(dshHome, 'agents'), DSH_TELEMETRY_MODE: 'DISABLED', PRESMIUM_MAX_THREADS: env.PRESMIUM_MAX_THREADS }, 'interactive')
+}
+
+/** The variables a launcher sets for the processes it starts; they are never inherited from its own environment. */
+export function isLauncherVariable(name: string): boolean {
+  return /^(?:DSH_|PRESMIUM_MODEL_|PRESMIUM_SERVICE_)/.test(name) || ['PRESMIUM_WORKSPACE', 'NODE_ENV', 'PORT'].includes(name)
+}
+
+export function inheritedEnv(env: NodeJS.ProcessEnv, drop: (name: string) => boolean): Record<string, string> {
+  return Object.fromEntries(Object.entries(env).filter((entry): entry is [string, string] => entry[1] !== undefined && !drop(entry[0])))
+}
+
+/** The environment of the workspace server: the launcher's, without the variables of DeepSeek Harness, of its model and of the launcher, with the service token. */
+export function workspaceServerEnv(env: NodeJS.ProcessEnv, serviceToken: string): Record<string, string> {
+  return { ...inheritedEnv(env, name => isLauncherVariable(name) || name.startsWith('DEEPSEEK_')), PRESMIUM_SERVICE_TOKEN: serviceToken }
+}
+
+export interface LaunchedProcess {
+  child: ChildProcess
+  /** The first match of `pattern` in the output, once it is printed; rejects when the process ends first or takes over 3 minutes. */
+  ready(pattern: RegExp): Promise<RegExpExecArray>
+  /** Stops keeping the output for `ready`, once the process is ready. */
+  stopBuffering(): void
+  exited: Promise<void>
+  /** SIGTERM, then SIGKILL to the whole process group after 15 s. */
+  stop(): Promise<void>
+}
+
+/**
+ * Starts `node <args>` under the watchdog, in a process group of its own, with the interactive thread budget at normal
+ * priority: the author waits for the workspace service and DeepSeek Harness. The watchdog ends the group when the
+ * launcher's pipe to it closes, so the group ends with the launcher, after `kill -9` too.
+ */
+export function launchNode(name: string, args: string[], options: { cwd: string, env: Record<string, string>, onOutput?(text: string): void }): LaunchedProcess {
+  const machine = machineState()
+  const node = nodeResourceArgs('interactive', options.env, machine)
+  const child = spawn(process.execPath, [...NODE_RESOURCE_ARGS, WATCHDOG, process.execPath, ...node, ...args], { cwd: options.cwd, env: resourceEnvironment(options.env, 'interactive', machine), detached: true, stdio: ['pipe', 'pipe', 'pipe'] })
+  child.stdin!.on('error', () => {})
+  let output: string | undefined = ''
+  const waiting = new Set<() => void>()
+  const read = (chunk: Buffer) => {
+    const text = chunk.toString()
+    options.onOutput?.(text)
+    if (output === undefined) return
+    output = (output + text).slice(-20_000)
+    for (const check of waiting) check()
+  }
+  child.stdout!.on('data', read)
+  child.stderr!.on('data', read)
+  let ended = false
+  const exited = new Promise<void>(done => child.once('exit', () => {
+    ended = true
+    done()
+  }))
+  return {
+    child,
+    exited,
+    ready(pattern) {
+      return new Promise((resolveReady, reject) => {
+        const tail = () => (output ?? '').trimEnd().split('\n').slice(-12).map(line => `  ${line}`).join('\n')
+        const timer = setTimeout(() => finish(new Error(`${name} did not start within ${READY_MS / 1000} s:\n${tail()}\n`)), READY_MS)
+        const check = () => {
+          const match = pattern.exec(output ?? '')
+          if (match) finish(match)
+        }
+        const finish = (result: RegExpExecArray | Error) => {
+          clearTimeout(timer)
+          waiting.delete(check)
+          if (result instanceof Error) reject(result)
+          else resolveReady(result)
+        }
+        waiting.add(check)
+        void exited.then(() => finish(new Error(`${name} ended before it was ready:\n${tail()}\n`)))
+        check()
+      })
+    },
+    stopBuffering() {
+      output = undefined
+    },
+    async stop() {
+      if (ended) return
+      child.kill('SIGTERM')
+      const timer = setTimeout(() => {
+        try {
+          process.kill(-child.pid!, 'SIGKILL')
+        } catch {
+        }
+      }, STOP_MS)
+      await exited
+      clearTimeout(timer)
+    },
+  }
+}
+
+export interface LaunchedWorkspaceServer {
+  process: LaunchedProcess
+  /** The server's address and the workspace root, once `presmium serve` printed them. */
+  ready: Promise<{ url: string, root: string }>
+}
+
+/** Starts `presmium serve <dir> --port <port, default 0: a free one> [args]` with `launchNode`, in `workspaceServerEnv`. */
+export function launchWorkspaceServer(options: { presmium: string, dir: string, serviceToken: string, port?: number, args?: string[], env?: NodeJS.ProcessEnv, onOutput?(text: string): void }): LaunchedWorkspaceServer {
+  const server = launchNode('presmium serve', [options.presmium, 'serve', options.dir, '--port', String(options.port ?? 0), ...options.args ?? []], {
+    cwd: options.dir,
+    env: workspaceServerEnv(options.env ?? process.env, options.serviceToken),
+    ...options.onOutput ? { onOutput: options.onOutput } : {},
+  })
+  const ready = (async () => {
+    const url = (await server.ready(SERVE_READY))[1]!
+    const root = (await server.ready(WORKSPACE_READY))[1]!.trim()
+    server.stopBuffering()
+    return { url, root }
+  })()
+  return { process: server, ready }
 }
 
 export function writeProfile(dshHome: string, name: string, carrier: Carrier, bundle = PACKAGE_DIR): string {

package/src/node/policy.ts

@@ -1,59 +1,56 @@
 import { homedir } from 'node:os'
-import { isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { join, resolve } from 'node:path'
+import { isInside } from '@lincyaw/kernel/node'
 import { describeOperation } from '@lincyaw/mcp/client'
-import type { DshContext, DshPreDecision, DshToolExecution } from './dsh.ts'
+import type { DshContext, DshPreDecision, DshToolExecution } from './dsh-types.ts'
 import { PREFIX } from './tools.ts'
 
 export const name = 'presmium-policy'
 export const inject = ['presmium', 'tools']
 
-const FILE_TOOLS = new Set(['write', 'edit', 'str_replace_editor'])
+const FILE_WRITE_TOOLS = new Set(['write', 'edit', 'str_replace_editor'])
 
 export function operatorRoot(env: NodeJS.ProcessEnv = process.env): string {
   return resolve(env.PRESMIUM_OPERATOR_DIR || join(env.XDG_STATE_HOME || join(homedir(), '.local', 'state'), 'presmium', 'operator'))
 }
 
-function inside(path: string, dir: string): boolean {
-  const rel = relative(dir, path)
-  return rel === '' || (rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel))
-}
-
 function fileOf(exec: Readonly<DshToolExecution>): string | undefined {
   const args = exec.arguments as { file_path?: unknown, path?: unknown } | undefined
   const path = args?.file_path ?? args?.path
   return typeof path === 'string' && path !== '' ? path : undefined
 }
 
-const shown = (text: string, lang?: string) => ({ en: text, ...lang ? { [lang]: text } : {} })
+const displayText = (text: string, lang?: string) => ({ en: text, ...lang ? { [lang]: text } : {} })
 
 export function apply(ctx: DshContext): void {
-  const operators = operatorRoot()
+  const operatorDir = operatorRoot()
 
   ctx.on('tools/pre-execute', async (exec: DshToolExecution, next: () => Promise<DshPreDecision>): Promise<DshPreDecision> => {
-    const session = ctx.presmium.session(exec.agent)
+    const { bindings } = ctx.presmium
+    const binding = bindings.bindingOf(exec.agent)
     if (exec.name.startsWith(PREFIX)) {
-      const tool = session?.tools.find(own => `${PREFIX}${own.name}` === exec.name)
-      if (!session || !tool) return { kind: 'deny', reason: `Presmium: ${exec.name} is no tool of this session's document` }
+      const tool = binding?.tools.find(own => `${PREFIX}${own.name}` === exec.name)
+      if (!binding || !tool) return { kind: 'deny', reason: `Presmium: ${exec.name} is no tool of this session's document` }
       if (tool.kind === 'read') return next()
       if (tool.approval === 'allow') return { kind: 'allow' }
-      const lang = session.document.lang
+      const lang = binding.document.lang
       const title = describeOperation(tool.name, (exec.arguments ?? {}) as Record<string, unknown>, lang)
-      return { kind: 'ask', reason: `presmium:${tool.kind} ${tool.name}`, displayReason: shown(`Presmium · ${title}`, lang) }
+      return { kind: 'ask', reason: `presmium:${tool.kind} ${tool.name}`, displayReason: displayText(`Presmium · ${title}`, lang) }
     }
-    const file = FILE_TOOLS.has(exec.name) ? fileOf(exec) : undefined
-    if (file && inside(resolve(exec.agent ? ctx.presmium.directoryOf(exec.agent) : process.cwd(), file), operators)) return next()
-    if (session && file && !inside(resolve(ctx.presmium.directoryOf(exec.agent!), file), ctx.presmium.directoryOf(exec.agent!))) {
-      return { kind: 'ask', reason: `presmium:write ${file}`, displayReason: shown(`Presmium · ${file}`, session.document.lang) }
+    const file = FILE_WRITE_TOOLS.has(exec.name) ? fileOf(exec) : undefined
+    if (file && isInside(resolve(exec.agent ? bindings.workingDirectoryOf(exec.agent) : process.cwd(), file), operatorDir)) return next()
+    if (binding && file && !isInside(resolve(bindings.workingDirectoryOf(exec.agent!), file), bindings.workingDirectoryOf(exec.agent!))) {
+      return { kind: 'ask', reason: `presmium:write ${file}`, displayReason: displayText(`Presmium · ${file}`, binding.document.lang) }
     }
     return next()
   })
 
   ctx.tools.guard((exec) => {
-    const file = FILE_TOOLS.has(exec.name) ? fileOf(exec) : undefined
-    const dir = exec.agent ? ctx.presmium.directoryOf(exec.agent) : process.cwd()
-    if (file && inside(resolve(dir, file), operators)) return `Presmium: the operator directory (${operators}) is not the agent's to write`
+    const file = FILE_WRITE_TOOLS.has(exec.name) ? fileOf(exec) : undefined
+    const dir = exec.agent ? ctx.presmium.bindings.workingDirectoryOf(exec.agent) : process.cwd()
+    if (file && isInside(resolve(dir, file), operatorDir)) return `Presmium: the operator directory (${operatorDir}) is not the agent's to write`
     const command = exec.name === 'bash' ? (exec.arguments as { command?: unknown } | undefined)?.command : undefined
-    if (typeof command === 'string' && command.includes(operators)) return `Presmium: the operator directory (${operators}) is not the agent's to touch`
+    if (typeof command === 'string' && command.includes(operatorDir)) return `Presmium: the operator directory (${operatorDir}) is not the agent's to touch`
     return undefined
   })
 }

package/src/node/routes.ts

@@ -1,20 +1,29 @@
-import type { DshContext } from './dsh.ts'
+import type { DshContext } from './dsh-types.ts'
+import { SERVER_ROUTES, WORKSPACE_ROUTES } from './server-routes.ts'
 
 export const name = 'presmium-routes'
 export const inject = ['presmium', 'connection']
 
-const WORKSPACE = '/__presmium/presmium.workspace/'
-const SERVER = '/__presmium/presmium.server/'
-
 export const ROUTES: Record<string, string> = Object.fromEntries([
-  ...['documents', 'files', 'source', 'changes', 'changes/commit', 'changes/discard', 'revisions', 'revisions/revert',
-    'ir', 'ir/events', 'preview', 'build', 'check',
-    'review', 'review/open', 'review/step', 'review/accept', 'review/reject', 'review/restore'].map(path => [path, `${WORKSPACE}${path}`]),
-  ['focus', `${SERVER}focus`],
+  ['speech-settings', `${WORKSPACE_ROUTES}speech-settings`],
+  ...['project/capabilities', 'project/plan', 'project/apply', 'documents', 'document', 'document/capabilities', 'document/outline', 'document/part', 'document/page/plan', 'document/page/apply', 'document/action/plan', 'document/action/impact', 'document/action/apply', 'document/asset', 'document/events', 'document/change', 'document/image', 'document/audio', 'document/recording/adopt', 'document/media-clip', 'files', 'source', 'source/create', 'source/transaction', 'changes', 'changes/commit', 'changes/discard', 'revisions', 'revisions/revert', 'history/list', 'history/file', 'history/undo', 'history/redo',
+    'document/media-clip/validate', 'document/transcription/capabilities', 'document/transcription', 'document/transcription/result', 'document/transcription/cancel',
+    'document/transcription/adoption/plan', 'document/transcription/adoption/apply',
+    'ir', 'ir/events', 'preview', 'build', 'check', 'jobs', 'jobs/cancel', 'jobs/events', 'voice-catalog', 'voice-capabilities',
+    'review', 'review/open', 'review/step', 'review/accept', 'review/reject', 'review/restore'].map(path => [path, `${WORKSPACE_ROUTES}${path}`]),
+  ['focus', `${SERVER_ROUTES}focus`],
+  ['control', `${SERVER_ROUTES}control`],
+  ['diagnostics', `${SERVER_ROUTES}diagnostics`],
+  ['diagnostics/events', `${SERVER_ROUTES}diagnostics/events`],
+  ['diagnostics/authoring', `${SERVER_ROUTES}diagnostics/authoring`],
+  ...['voiceover', 'voiceover/jobs', 'voiceover/job', 'voiceover/cancel', 'voice-preview', 'voice-preview/media', 'production-plan', 'production-media', 'production-asset'].map(path => [path, `/__presmium/presmium.lecture/${path}`]),
+  // Training a cloned voice and its status: the speech plugin's owner routes.
+  ['voice-clone', '/__presmium/presmium.speech/clone'],
+  ['voice-clone/status', '/__presmium/presmium.speech/clone/status'],
 ])
 
-const PASSED = ['accept', 'content-type', 'presmium-document', 'last-event-id']
-const RETURNED = ['content-type', 'cache-control', 'content-disposition', 'x-accel-buffering']
+const PASSED = ['accept', 'content-type', 'presmium-document', 'last-event-id', 'if-none-match']
+const RETURNED = ['content-type', 'cache-control', 'content-disposition', 'content-security-policy', 'x-content-type-options', 'cross-origin-resource-policy', 'x-accel-buffering', 'etag', 'retry-after']
 
 export function apply(ctx: DshContext): void {
   for (const [path, target] of Object.entries(ROUTES)) {
@@ -28,12 +37,13 @@ export function apply(ctx: DshContext): void {
           const value = request.headers.get(name)
           if (value !== null) headers[name] = value
         }
-        const upstream = await ctx.presmium.request(`${target}${new URL(request.url).search}`, {
+        const upstream = await ctx.presmium.server.request(`${target}${new URL(request.url).search}`, {
           method: request.method,
           headers,
           ...request.method === 'POST' ? { raw: await request.arrayBuffer() } : {},
           signal: request.signal,
         })
+        if ((path === 'documents' || path === 'project/apply') && request.method === 'POST' && upstream.ok) ctx.presmium.server.invalidateDocuments()
         const answered = new Headers()
         for (const name of RETURNED) {
           const value = upstream.headers.get(name)

package/src/node/server-routes.ts

@@ -0,0 +1,3 @@
+/** Where the workspace server mounts the routes of its workspace plugin and its own routes. */
+export const WORKSPACE_ROUTES = '/__presmium/presmium.workspace/'
+export const SERVER_ROUTES = '/__presmium/presmium.server/'