@lincyaw/dsh 0.0.0-stage → 0.1.0

package/src/node/dsh.ts

@@ -0,0 +1,93 @@
+import type { PresmiumService } from './service.ts'
+
+export interface DshLogger {
+  info(format: string, ...args: unknown[]): void
+  warn(format: string, ...args: unknown[]): void
+  debug(format: string, ...args: unknown[]): void
+}
+
+export interface DshSession {
+  readonly id: string
+  readonly header?: { cwd?: string }
+}
+
+export interface DshAgent {
+  readonly session: DshSession
+  readonly ctx: DshContext
+  whenIdle(): Promise<void>
+}
+
+export interface DshToolExecution {
+  readonly callId: string
+  readonly name: string
+  readonly arguments: unknown
+  readonly agent?: DshAgent
+  readonly signal: AbortSignal
+}
+
+export type DshPreDecision =
+  | { kind: 'allow' }
+  | { kind: 'deny', reason: string }
+  | { kind: 'ask', reason?: string, displayReason?: { en: string, [locale: string]: string } }
+
+export interface DshToolDefinition {
+  name: string
+  description: string
+  parameters: Record<string, unknown>
+  output: { schema: Record<string, unknown>, render(args: unknown, value: unknown): { type: 'text', text: string }[] }
+  execute(args: unknown, exec: DshToolExecution): Promise<unknown>
+}
+
+export interface DshTools {
+  register(definition: DshToolDefinition): () => void
+  guard(guard: (exec: Readonly<DshToolExecution>) => string | undefined): () => void
+}
+
+export interface DshPromptPart {
+  name: string
+  order: number
+  text: string | (() => string)
+  interpolate?: boolean
+  required?: boolean
+}
+
+export interface DshSystemPrompt {
+  section(section: DshPromptPart): () => void
+  context(context: DshPromptPart): () => void
+}
+
+export interface DshSkill {
+  name: string
+  description: string
+  content: string
+  path: string
+  source: 'bundled'
+  resourceBase: { kind: 'directory', path: string }
+}
+
+export interface DshFetchRoute {
+  path: string
+  methods: ('GET' | 'HEAD' | 'POST')[]
+  requestBody: 'buffered' | 'streaming'
+  fetch(request: Request): Promise<Response>
+}
+
+export interface DshWorkspaces {
+  create(path: string, title?: string): Promise<{ id: string, path: string, title: string, setTitle(title: string): Promise<void> }>
+  list(): { id: string, path: string, title: string, setTitle(title: string): Promise<void> }[]
+  delete(id: string): Promise<boolean>
+}
+
+export interface DshContext {
+  get(name: string): unknown
+  provide(name: string, value: unknown): void
+  on(event: string, listener: (...args: any[]) => unknown): () => void
+  effect(effect: () => () => void): void
+  logger?: (name: string) => DshLogger
+  tools: DshTools
+  systemPrompt: DshSystemPrompt
+  skills: { register(skill: DshSkill): () => void }
+  connection: { fetch: { register(route: DshFetchRoute): () => Promise<void> } }
+  workspaceRegistry: DshWorkspaces
+  presmium: PresmiumService
+}

package/src/node/launch.ts

@@ -0,0 +1,59 @@
+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'
+
+export type Carrier = 'web' | 'headless' | 'acp'
+
+export const PACKAGE_DIR = fileURLToPath(new URL('../..', import.meta.url))
+export const PACKAGE_NAME = '@lincyaw/dsh'
+
+const CARRIERS: Record<Carrier, string> = {
+  web: '@deepseek-ai/dsh-web-app',
+  headless: '@deepseek-ai/dsh-headless',
+  acp: '@deepseek-ai/dsh-acp-app',
+}
+
+export function launchPatches(carrier: Carrier): string[] {
+  return [...carrier === 'web' ? [join(PACKAGE_DIR, 'web.patch.yml')] : [], join(PACKAGE_DIR, 'profile.patch.yml')]
+}
+
+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
+}
+
+export function dshBin(from = PACKAGE_DIR): string {
+  const manifest = createRequire(join(from, 'package.json')).resolve('@deepseek-ai/dsh/package.json')
+  const { bin } = JSON.parse(readFileSync(manifest, 'utf8')) as { bin: string | Record<string, 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 writeProfile(dshHome: string, name: string, carrier: Carrier, bundle = PACKAGE_DIR): string {
+  const dir = join(dshHome, 'profiles', name)
+  mkdirSync(join(dir, 'node_modules', '@lincyaw'), { recursive: true })
+  mkdirSync(join(dshHome, 'agents'), { recursive: true })
+  writeFileSync(join(dir, 'package.json'), `${JSON.stringify({
+    name: `dsh-profile-${name}`,
+    private: true,
+    dependencies: {},
+    dsh: { profile: { bundles: ['@deepseek-ai/dsh-base', CARRIERS[carrier], PACKAGE_NAME] } },
+  }, null, 2)}\n`)
+  writeFileSync(join(dir, 'cordis.yml'), '# The profile root: an empty entry list; the tree is composed from the bundles and the patches.\n[]\n')
+  if (!existsSync(join(dir, 'cordis.patch.yml'))) writeFileSync(join(dir, 'cordis.patch.yml'), '# Your patch layer for this profile (Presmium\'s settings are passed with --patch after it).\n[]\n')
+  const link = join(dir, 'node_modules', PACKAGE_NAME)
+  rmSync(link, { force: true, recursive: true })
+  symlinkSync(realpathSync(bundle), link, 'junction')
+  return dir
+}

package/src/node/policy.ts

@@ -0,0 +1,59 @@
+import { homedir } from 'node:os'
+import { isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { describeOperation } from '@lincyaw/mcp/client'
+import type { DshContext, DshPreDecision, DshToolExecution } from './dsh.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'])
+
+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 } : {} })
+
+export function apply(ctx: DshContext): void {
+  const operators = operatorRoot()
+
+  ctx.on('tools/pre-execute', async (exec: DshToolExecution, next: () => Promise<DshPreDecision>): Promise<DshPreDecision> => {
+    const session = ctx.presmium.session(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` }
+      if (tool.kind === 'read') return next()
+      if (tool.approval === 'allow') return { kind: 'allow' }
+      const lang = session.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) }
+    }
+    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) }
+    }
+    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 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`
+    return undefined
+  })
+}

package/src/node/routes.ts

@@ -0,0 +1,46 @@
+import type { DshContext } from './dsh.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`],
+])
+
+const PASSED = ['accept', 'content-type', 'presmium-document', 'last-event-id']
+const RETURNED = ['content-type', 'cache-control', 'content-disposition', 'x-accel-buffering']
+
+export function apply(ctx: DshContext): void {
+  for (const [path, target] of Object.entries(ROUTES)) {
+    ctx.connection.fetch.register({
+      path: `/api/presmium/${path}`,
+      methods: ['GET', 'POST'],
+      requestBody: 'buffered',
+      async fetch(request) {
+        const headers: Record<string, string> = {}
+        for (const name of PASSED) {
+          const value = request.headers.get(name)
+          if (value !== null) headers[name] = value
+        }
+        const upstream = await ctx.presmium.request(`${target}${new URL(request.url).search}`, {
+          method: request.method,
+          headers,
+          ...request.method === 'POST' ? { raw: await request.arrayBuffer() } : {},
+          signal: request.signal,
+        })
+        const answered = new Headers()
+        for (const name of RETURNED) {
+          const value = upstream.headers.get(name)
+          if (value !== null) answered.set(name, value)
+        }
+        return new Response(upstream.body, { status: upstream.status, headers: answered })
+      },
+    })
+  }
+}

package/src/node/service.ts

@@ -0,0 +1,280 @@
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+import { randomBytes } from 'node:crypto'
+import { realpathSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join, relative, resolve, sep } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { connectPresmiumMcp } from '@lincyaw/mcp/client'
+import type { ListedTool, PresmiumMcpClient } from '@lincyaw/mcp/client'
+import type { DshAgent, DshContext, DshLogger } from './dsh.ts'
+
+export const name = 'presmium-service'
+
+export interface Config {
+  url?: string
+  token?: string
+  root?: string
+}
+
+export interface Endpoint {
+  url: string
+  token: string
+  root: string
+}
+
+export interface WorkspaceDocument {
+  dir: string
+  title: string
+  lang?: string
+}
+
+export interface PresmiumSession {
+  id: string
+  document: WorkspaceDocument
+  dir: string
+  client: PresmiumMcpClient
+  tools: ListedTool[]
+}
+
+const START_MS = 180_000
+const DOCUMENTS_MS = 2000
+const WATCHDOG = fileURLToPath(new URL('./watchdog.mjs', import.meta.url))
+
+function presmiumBin(): string {
+  const entry = createRequire(import.meta.url).resolve('@lincyaw/cli')
+  return join(dirname(dirname(entry)), 'bin', 'presmium.mjs')
+}
+
+function real(path: string): string {
+  try {
+    return realpathSync(path)
+  } catch {
+    return resolve(path)
+  }
+}
+
+export function documentAt(root: string, dir: string, documents: WorkspaceDocument[]): WorkspaceDocument | undefined {
+  const rel = relative(real(root), real(dir)).split(sep).join('/')
+  if (rel.startsWith('..')) return undefined
+  return documents.find(doc => doc.dir === rel)
+}
+
+function serviceEnv(token: string): NodeJS.ProcessEnv {
+  const env: NodeJS.ProcessEnv = {}
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith('DSH_') || key.startsWith('DEEPSEEK_') || key === 'NODE_ENV') continue
+    env[key] = value
+  }
+  return { ...env, PRESMIUM_SERVICE_TOKEN: token }
+}
+
+export class PresmiumService {
+  readonly ready: Promise<Endpoint>
+  readonly #ctx: DshContext
+  readonly #log: DshLogger
+  #child: ChildProcess | undefined
+  #documents: { at: number, list: Promise<WorkspaceDocument[]> } | undefined
+  readonly #opening = new Map<string, Promise<PresmiumSession | undefined>>()
+  readonly #open = new Map<string, PresmiumSession>()
+  readonly #refreshing = new Map<string, Promise<PresmiumSession | undefined>>()
+  readonly #selectionVersions = new Map<string, number>()
+  readonly #selectionListeners = new Map<string, { before(): Promise<void>, after(): Promise<void> }>()
+  readonly #selected = new Map<string, string | null>()
+  #closed = false
+
+  constructor(ctx: DshContext, config: Config, log: DshLogger) {
+    this.#ctx = ctx
+    this.#log = log
+    const root = resolve(config.root || process.cwd())
+    this.ready = config.url
+      ? Promise.resolve({ url: config.url.replace(/\/+$/, ''), token: config.token ?? '', root })
+      : this.#start(root)
+    this.ready.catch((error: unknown) => log.warn(`presmium-service: ${error instanceof Error ? error.message : String(error)}`))
+  }
+
+  #start(root: string): Promise<Endpoint> {
+    const token = randomBytes(24).toString('base64url')
+    const child = spawn(process.execPath, [WATCHDOG, process.execPath, presmiumBin(), 'serve', root, '--port', '0'], {
+      cwd: root,
+      env: serviceEnv(token),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      detached: true,
+    })
+    this.#child = child
+    child.stdin!.on('error', () => {})
+    let output = ''
+    return new Promise<Endpoint>((resolveStart, reject) => {
+      const timer = setTimeout(() => reject(new Error(`presmium serve did not start within ${START_MS / 1000} s:\n${output.slice(-2000)}`)), START_MS)
+      const read = (chunk: Buffer) => {
+        output = (output + chunk.toString()).slice(-20_000)
+        const url = /^serve {2}(http\S+)$/m.exec(output)?.[1]
+        const workspace = /^workspace {2}(.+)$/m.exec(output)?.[1]
+        if (url && workspace) {
+          clearTimeout(timer)
+          resolveStart({ url, token, root: workspace.trim() })
+        }
+      }
+      child.stdout!.on('data', read)
+      child.stderr!.on('data', (chunk: Buffer) => {
+        output = (output + chunk.toString()).slice(-20_000)
+        for (const line of chunk.toString().split('\n').filter(Boolean)) this.#log.debug(`presmium serve: ${line}`)
+      })
+      child.once('exit', (code, signal) => {
+        clearTimeout(timer)
+        if (!this.#closed) this.#log.warn(`presmium serve exited (${signal ?? code})`)
+        reject(new Error(`presmium serve exited (${signal ?? code}):\n${output.slice(-2000)}`))
+      })
+    })
+  }
+
+  async request(path: string, init: { method?: string, body?: unknown, raw?: ArrayBuffer, headers?: Record<string, string>, signal?: AbortSignal } = {}): Promise<Response> {
+    const { url, token } = await this.ready
+    const json = init.body !== undefined
+    return fetch(`${url}${path}`, {
+      method: init.method ?? (json || init.raw ? 'POST' : 'GET'),
+      headers: { ...json ? { 'Content-Type': 'application/json' } : {}, ...init.headers, ...token ? { Authorization: `Bearer ${token}` } : {} },
+      ...json ? { body: JSON.stringify(init.body) } : init.raw ? { body: init.raw } : {},
+      ...init.signal ? { signal: init.signal } : {},
+    })
+  }
+
+  async #json<T>(path: string, init?: Parameters<PresmiumService['request']>[1]): Promise<T> {
+    const response = await this.request(path, init)
+    const text = await response.text()
+    if (!response.ok) throw new Error(`${path} answered ${response.status}: ${text}`)
+    return JSON.parse(text) as T
+  }
+
+  documents(): Promise<WorkspaceDocument[]> {
+    if (!this.#documents || Date.now() - this.#documents.at > DOCUMENTS_MS) {
+      const list = this.#json<{ documents: WorkspaceDocument[] }>('/__presmium/presmium.workspace/documents').then(answer => answer.documents)
+      this.#documents = { at: Date.now(), list }
+      list.catch(() => this.#documents = undefined)
+    }
+    return this.#documents.list
+  }
+
+  directoryOf(agent: DshAgent): string {
+    const dirs = this.#ctx.get('workingDirectory') as { get(session: unknown): string } | undefined
+    try {
+      return dirs?.get(agent.session) ?? agent.session.header?.cwd ?? process.cwd()
+    } catch {
+      return agent.session.header?.cwd ?? process.cwd()
+    }
+  }
+
+  attach(agent: DshAgent): Promise<PresmiumSession | undefined> {
+    const id = agent.session.id
+    let known = this.#opening.get(id)
+    if (!known) {
+      known = this.#attach(agent).catch((error: unknown) => {
+        this.#log.warn(`presmium-service: the session ${id} has no Presmium tools: ${error instanceof Error ? error.message : String(error)}`)
+        this.#opening.delete(id)
+        return undefined
+      })
+      this.#opening.set(id, known)
+    }
+    return known
+  }
+
+  async #attach(agent: DshAgent): Promise<PresmiumSession | undefined> {
+    const { root } = await this.ready
+    const id = agent.session.id
+    const documents = await this.documents()
+    const selected = this.#selected.get(id)
+    const document = selected === undefined ? documentAt(root, this.directoryOf(agent), documents) : documents.find(doc => doc.dir === selected)
+    if (!document) return undefined
+    const grant = await this.#json<{ url: string, token: string }>('/__presmium/presmium.server/tokens', { body: { document: document.dir, session: id } })
+    const client = await connectPresmiumMcp(grant.url, grant.token)
+    const session: PresmiumSession = { id, document, dir: resolve(root, document.dir), client, tools: await client.tools() }
+    this.#open.set(id, session)
+    return session
+  }
+
+  async selectDocument(id: string, document: string | null): Promise<void> {
+    if (document !== null && !(await this.documents()).some(doc => doc.dir === document)) throw new Error('Unknown Presmium document')
+    const version = (this.#selectionVersions.get(id) ?? 0) + 1
+    this.#selectionVersions.set(id, version)
+    const listener = this.#selectionListeners.get(id)
+    await listener?.before()
+    if (this.#selectionVersions.get(id) !== version) return
+    this.#selected.set(id, document)
+    await listener?.after()
+  }
+
+  watchSelection(id: string, listener: { before(): Promise<void>, after(): Promise<void> }): () => void {
+    this.#selectionListeners.set(id, listener)
+    return () => { if (this.#selectionListeners.get(id) === listener) this.#selectionListeners.delete(id) }
+  }
+
+  refresh(agent: DshAgent): Promise<PresmiumSession | undefined> {
+    const id = agent.session.id
+    let pending = this.#refreshing.get(id)
+    if (!pending) {
+      pending = this.#refresh(agent).finally(() => this.#refreshing.delete(id))
+      this.#refreshing.set(id, pending)
+    }
+    return pending
+  }
+
+  async #refresh(agent: DshAgent): Promise<PresmiumSession | undefined> {
+    const id = agent.session.id
+    const selected = this.#selected.get(id)
+    const current = await this.attach(agent)
+    if (selected === undefined || current?.document.dir === selected || (!current && selected === null)) return current
+    await this.detach(id, false)
+    return this.attach(agent)
+  }
+
+  session(agent: DshAgent | undefined): PresmiumSession | undefined {
+    return agent ? this.#open.get(agent.session.id) : undefined
+  }
+
+  async detach(id: string, forget = true): Promise<void> {
+    if (forget) {
+      this.#selectionVersions.delete(id)
+      this.#selected.delete(id)
+      this.#selectionListeners.delete(id)
+    }
+    const session = this.#open.get(id)
+    this.#open.delete(id)
+    this.#opening.delete(id)
+    if (!session) return
+    await session.client.close().catch(() => undefined)
+    await this.request('/__presmium/presmium.server/tokens', { method: 'DELETE', body: { session: id } }).then(r => r.body?.cancel(), () => undefined)
+  }
+
+  async close(): Promise<void> {
+    this.#closed = true
+    for (const session of this.#open.values()) await session.client.close().catch(() => undefined)
+    this.#open.clear()
+    this.#opening.clear()
+    this.#selected.clear()
+    this.#selectionVersions.clear()
+    this.#selectionListeners.clear()
+    if (this.#child) {
+      this.#child.kill('SIGTERM')
+      return
+    }
+    await this.request('/__presmium/presmium.server/tokens', { method: 'DELETE', body: {} }).then(r => r.body?.cancel(), () => undefined)
+  }
+
+  stop(): void {
+    this.#closed = true
+    if (this.#child?.exitCode === null) this.#child.kill('SIGTERM')
+  }
+}
+
+export function apply(ctx: DshContext, config: Config = {}): void {
+  const log = ctx.logger?.('presmium') ?? console
+  const service = new PresmiumService(ctx, config, log)
+  ctx.provide('presmium', service)
+  ctx.on('session/disposed', (session: { id: string }) => void service.detach(session.id))
+  const stop = () => service.stop()
+  process.once('exit', stop)
+  ctx.effect(() => () => {
+    process.off('exit', stop)
+    void service.close()
+  })
+}

package/src/node/skills.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import type { DshContext } from './dsh.ts'
+
+export const name = 'presmium-skills'
+export const inject = ['skills']
+
+const PACKAGE = fileURLToPath(new URL('../..', import.meta.url))
+
+export function bundledSkills(): string[] {
+  const manifest = JSON.parse(readFileSync(join(PACKAGE, 'package.json'), 'utf8')) as { presmium?: { skills?: string[] } }
+  return manifest.presmium?.skills ?? []
+}
+
+export function skillDir(skill: string): string | undefined {
+  return [join(PACKAGE, '..', '..', '.agents', 'skills', skill), join(PACKAGE, 'skills', skill)].find(dir => existsSync(join(dir, 'SKILL.md')))
+}
+
+function field(frontmatter: string, key: string): string | undefined {
+  const raw = new RegExp(`^${key}:\\s*(.*)$`, 'm').exec(frontmatter)?.[1]?.trim()
+  if (!raw) return undefined
+  if (raw.startsWith('"')) {
+    try {
+      return JSON.parse(raw) as string
+    } catch {
+      return raw.slice(1, -1)
+    }
+  }
+  return raw.replace(/^'|'$/g, '')
+}
+
+export function apply(ctx: DshContext): void {
+  for (const skill of bundledSkills()) {
+    const dir = skillDir(skill)
+    if (!dir) {
+      ctx.logger?.('presmium').warn(`presmium-skills: the skill ${skill} is not in this package`)
+      continue
+    }
+    const path = join(dir, 'SKILL.md')
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(readFileSync(path, 'utf8'))
+    const description = match && field(match[1]!, 'description')
+    if (!match || !description) continue
+    ctx.skills.register({ name: field(match[1]!, 'name') ?? skill, description, content: match[2]!, path, source: 'bundled', resourceBase: { kind: 'directory', path: dir } })
+  }
+}

package/src/node/tools.ts

@@ -0,0 +1,43 @@
+import type { ListedTool } from '@lincyaw/mcp/client'
+import type { DshAgent, DshContext, DshToolDefinition } from './dsh.ts'
+import type { PresmiumSession } from './service.ts'
+
+export const name = 'presmium-tools'
+export const inject = ['presmium', 'tools']
+
+export const PREFIX = 'presmium__'
+
+function definition(session: PresmiumSession, tool: ListedTool): DshToolDefinition {
+  return {
+    name: `${PREFIX}${tool.name}`,
+    description: tool.description,
+    parameters: tool.inputSchema,
+    output: { schema: { type: 'string' }, render: (_args, value) => [{ type: 'text', text: String(value) }] },
+    async execute(args, exec) {
+      const result = await session.client.call(tool.name, (args ?? {}) as Record<string, unknown>, exec.signal)
+      if (result.isError) throw new Error(result.text)
+      return result.text
+    },
+  }
+}
+
+export function apply(ctx: DshContext): void {
+  const selections = new WeakMap<DshAgent, () => void>()
+  const registered = new WeakMap<DshAgent, { session?: PresmiumSession, dispose: (() => void)[] }>()
+  const sync = async (agent: DshAgent) => {
+    const session = await ctx.presmium.refresh(agent)
+    const previous = registered.get(agent)
+    if (previous && previous.session === session) return
+    for (const dispose of previous?.dispose ?? []) dispose()
+    registered.set(agent, { session, dispose: session?.tools.map(tool => agent.ctx.tools.register(definition(session, tool))) ?? [] })
+  }
+  ctx.on('agent/created', async ({ agent }: { agent: DshAgent }) => {
+    await sync(agent)
+    selections.set(agent, ctx.presmium.watchSelection(agent.session.id, { before: () => agent.whenIdle(), after: () => sync(agent) }))
+  })
+  ctx.on('agent/disposed', ({ agent }: { agent: DshAgent }) => { selections.get(agent)?.(); selections.delete(agent) })
+  ctx.on('agent/pre-step', async ({ agent }: { agent: DshAgent }, next: () => Promise<unknown>) => {
+    await sync(agent)
+    return next()
+  })
+}