@tiphareth/dsh-hardssh 0.1.2-alpha

package/src/switch/switch-fs.ts

@@ -0,0 +1,253 @@
+/**
+ * The `ctx.fs` switching facade: routes every filesystem call to the backend
+ * of the SESSION's workspace — a local session operates on the local sandbox,
+ * an SSH-bound workspace on the remote host the workspace is bound to.
+ *
+ * Routing anchor: the cwd the tool call was made under (`resolve`'s
+ * `opts.cwd`, the write/edit `sandboxPolicy.workspaceRoot`). The resolver
+ * ("which SSH workspace owns this cwd?") lives in the deps; a hit routes to
+ * that workspace's remote backend, a miss to the local backend. Later
+ * operations (stat/read/write) receive only the resolved `FsTarget`, so the
+ * backend identity is encoded into the target key — `ssh:<recordId>:<remoteKey>`
+ * for remote targets, bare local keys for local ones — and decoded on every
+ * dispatch. This keeps two SSH workspaces on DIFFERENT hosts (or different
+ * directories on the SAME host) from colliding, and never misroutes a local
+ * target.
+ *
+ * @module dsh-hardssh/switch-fs
+ */
+
+import { FileSystem } from '@deepseek-ai/dsh-fs'
+import type {
+  FsDirEntry,
+  FsEditOutcome,
+  FsEditRequest,
+  FsInfo,
+  FsPathInfo,
+  FsTarget,
+  FsWriteIntent,
+  FsWriteOutcome,
+} from '@deepseek-ai/dsh-fs'
+import type { SandboxExecutionPolicy, SandboxMode } from '@deepseek-ai/dsh-sandbox'
+import type { Context } from '@deepseek-ai/cordis'
+
+/** Key namespace: 'ssh:<recordId>:' (legacy) or 'wfs://<id>/' (current)
+ *  for remote/workspace-bound targets. Both decode; new keys emit wfs://. */
+export const REMOTE_PREFIX = 'ssh:'
+/** New URI-style workspace namespace marker. */
+export const WFS_PREFIX = 'wfs://'
+/** Strict WFS key prefix (includes the double slash + separator). */
+export const WFS_NAMESPACE_MARKER = `${WFS_PREFIX}`
+
+/** Route one cwd anchor to a backend + namespace. */
+export interface WorkspaceWorld {
+  backend: FileSystem
+  /** '' for local; 'wfs://<id>/' or legacy 'ssh:<recordId>:' for one workspace. */
+  namespace: string
+  /** The local anchor dir of the SSH workspace ('' for local) — used to
+   *  translate a model-supplied anchor path into the remote root. */
+  anchorPath?: string
+  /** The remote root of the SSH workspace ('' for local). */
+  remoteRoot?: string
+}
+
+/** Routing resolver offered by the mount site. */
+export interface SwitchFsDeps {
+  local: FileSystem
+  /** The world for a session cwd (undefined = local). */
+  worldFor(cwd: string | undefined): WorkspaceWorld
+  /** The world owning one namespaced target key (never undefined: every
+   *  key this facade issued maps back). */
+  worldForNamespace(namespace: string): WorkspaceWorld | undefined
+}
+
+/** The routing filesystem facade. */
+export class SwitchFileSystem extends FileSystem {
+  private readonly local: FileSystem
+
+  constructor(ctx: Context, private readonly deps: SwitchFsDeps) {
+    super(ctx)
+    this.local = deps.local
+  }
+
+  /** Sandbox default from the local backend (remote worlds are unconfined —
+   *  the docs/doc of the tool layer reads this once at mount). */
+  override get sandboxMode(): SandboxMode | undefined {
+    return this.local.sandboxMode
+  }
+
+  /** Encode a raw key into the world's namespace. */
+  private encode(rawKey: string, namespace: string): string {
+    return namespace === '' ? rawKey : `${namespace}${rawKey}`
+  }
+
+  /** Decode a namespaced key back to (rawKey, world). Supports both the
+   *  current `wfs://<id>/…` form and the legacy `ssh:<recordId>:…` form. */
+  private decode(key: string): { rawKey: string; world: WorkspaceWorld } | undefined {
+    if (key.startsWith(WFS_NAMESPACE_MARKER)) {
+      // wfs://<encodedId>/<raw path>
+      const rest = key.slice(WFS_NAMESPACE_MARKER.length)
+      const end = rest.indexOf('/')
+      if (end > 0) {
+        const namespace = `wfs://${rest.slice(0, end + 1)}` // 'wfs://<id>/'
+        const world = this.deps.worldForNamespace(namespace)
+        if (world !== undefined) return { rawKey: rest.slice(end + 1), world }
+      }
+      // Unknown workspace namespace: fail closed (never fall through to local).
+      return undefined
+    }
+    if (key.startsWith(REMOTE_PREFIX)) {
+      const end = key.indexOf(':', REMOTE_PREFIX.length)
+      if (end > 0) {
+        const namespace = key.slice(0, end + 1)
+        const world = this.deps.worldForNamespace(namespace)
+        if (world !== undefined) return { rawKey: key.slice(namespace.length), world }
+      }
+      // Unknown SSH namespace: the owning workspace was removed (or the key
+      // is stale from before a plugin reload). Fail closed — never fall
+      // through to the local backend with a remote key, which could silently
+      // misroute an operation to the wrong filesystem. Callers treat an
+      // undefined decode as "cannot route this target".
+      return undefined
+    }
+    return { rawKey: key, world: { backend: this.local, namespace: '' } }
+  }
+
+  override async resolve(path: string, opts?: { cwd?: string; signal?: AbortSignal }): Promise<FsTarget> {
+    const world = this.deps.worldFor(opts?.cwd)
+    // Translate a model-supplied LOCAL ANCHOR path into the remote root when
+    // the call routes to an SSH workspace: the model sees the anchor as "the
+    // current directory" (the session cwd) and may pass it verbatim. Rewrite
+    // `<anchor>` / `<anchor>/…` to `<remoteRoot>` / `<remoteRoot>/…` so the
+    // remote backend resolves it cleanly instead of glueing a Windows path
+    // onto /data/….
+    const effectivePath = world.anchorPath !== undefined && world.remoteRoot !== undefined
+      ? this.translateAnchorPath(world.anchorPath, world.remoteRoot, path)
+      : path
+    const raw = await world.backend.resolve(effectivePath, opts)
+    return {
+      targetKey: this.encode(String(raw.targetKey), world.namespace) as FsTarget['targetKey'],
+      displayPath: raw.displayPath,
+    }
+  }
+
+  /** Rewrite `<anchor>/<rest>` to `<remoteRoot>/<rest>` when `path` is the
+   *  anchor or under it; otherwise return `path` unchanged (remote absolute
+   *  paths, relative paths, and foreign local paths all pass through). */
+  private translateAnchorPath(anchor: string, remoteRoot: string, path: string): string {
+    const norm = (value: string): string => value.replace(/[\\/]+$/, '')
+    const a = norm(anchor)
+    const isWin = a.includes('\\')
+    const normPath = (value: string): string => {
+      let out = norm(value)
+      if (isWin) out = out.replace(/\//g, '\\')
+      return out
+    }
+    const p = normPath(path)
+    const aa = isWin ? a.toLowerCase() : a
+    const pp = isWin ? p.toLowerCase() : p
+    if (pp === aa) return remoteRoot
+    if (pp.startsWith(`${aa}\\`) || pp.startsWith(`${aa}/`)) {
+      // Preserve the original case for the tail (the anchor prefix removed);
+      // normalize the tail to POSIX separators (the remote side is POSIX).
+      const tail = p.slice(a.length).replace(/^[\\/]+/, '').replace(/\\/g, '/')
+      return tail === '' ? remoteRoot : `${remoteRoot.replace(/\/+$/, '')}/${tail}`
+    }
+    return path
+  }
+
+  override processPath(target: FsTarget): string {
+    const key = String(target.targetKey)
+    const decoded = this.decode(key)
+    return decoded?.world.backend.processPath({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }) ?? key
+  }
+
+  override fileUrl(target: FsTarget): string {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) return this.local.fileUrl(target)
+    return decoded.world.backend.fileUrl({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath })
+  }
+
+  override contains(parent: FsTarget, child: FsTarget): boolean {
+    const p = this.decode(String(parent.targetKey))
+    const c = this.decode(String(child.targetKey))
+    if (p === undefined || c === undefined || p.world.backend !== c.world.backend) return false
+    return p.world.backend.contains(
+      { targetKey: p.rawKey as FsTarget['targetKey'], displayPath: parent.displayPath },
+      { targetKey: c.rawKey as FsTarget['targetKey'], displayPath: child.displayPath },
+    )
+  }
+
+  override async stat(target: FsTarget, signal?: AbortSignal): Promise<FsInfo | undefined> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) return undefined
+    return decoded.world.backend.stat({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, signal)
+  }
+
+  override async lstat(path: string, opts?: { cwd?: string }, signal?: AbortSignal): Promise<FsPathInfo | undefined> {
+    const world = this.deps.worldFor(opts?.cwd)
+    const effectivePath = world.anchorPath !== undefined && world.remoteRoot !== undefined
+      ? this.translateAnchorPath(world.anchorPath, world.remoteRoot, path)
+      : path
+    return world.backend.lstat(effectivePath, opts, signal)
+  }
+
+  override async readText(target: FsTarget, signal?: AbortSignal): Promise<string> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    return decoded.world.backend.readText({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, signal)
+  }
+
+  override async streamText(target: FsTarget, signal?: AbortSignal): Promise<AsyncIterable<string>> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    return decoded.world.backend.streamText({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, signal)
+  }
+
+  override async readBytes(target: FsTarget, signal: AbortSignal | undefined, maxBytes: number): Promise<Uint8Array> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    return decoded.world.backend.readBytes({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, signal, maxBytes)
+  }
+
+  override async listDir(target: FsTarget, signal?: AbortSignal): Promise<FsDirEntry[]> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    const entries = await decoded.world.backend.listDir({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, signal)
+    if (decoded.world.namespace === '') return entries
+    // Re-namespace child targets so they stay routable.
+    return entries.map((entry) => ({
+      ...entry,
+      target: {
+        targetKey: this.encode(String(entry.target.targetKey), decoded.world.namespace) as FsTarget['targetKey'],
+        displayPath: entry.target.displayPath,
+      },
+    }))
+  }
+
+  override async writeText(
+    target: FsTarget,
+    content: string,
+    expected?: FsWriteIntent,
+    signal?: AbortSignal,
+    sandboxPolicy?: SandboxExecutionPolicy,
+  ): Promise<FsWriteOutcome> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    return decoded.world.backend.writeText({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, content, expected, signal, sandboxPolicy)
+  }
+
+  override async editText(
+    target: FsTarget,
+    edit: FsEditRequest,
+    expected?: { version: ReturnType<typeof import('@deepseek-ai/dsh-fs').FsVersion> },
+    signal?: AbortSignal,
+    sandboxPolicy?: Parameters<FileSystem['editText']>[4],
+  ): Promise<FsEditOutcome> {
+    const decoded = this.decode(String(target.targetKey))
+    if (decoded === undefined) throw new Error('fs-ssh: cannot route target')
+    return decoded.world.backend.editText({ targetKey: decoded.rawKey as FsTarget['targetKey'], displayPath: target.displayPath }, edit, expected, signal, sandboxPolicy)
+  }
+}
+
+export default SwitchFileSystem

package/src/switch/switch-subprocess.ts

@@ -0,0 +1,59 @@
+/**
+ * The `ctx.subprocess` switching facade: routes every spawn to the execution
+ * world of the SESSION's workspace — local sessions spawn locally, SSH-bound
+ * workspaces spawn on the bound host. The routing anchor is the spawn spec's
+ * `cwd` (bash tools default it to the session cwd); the resolver lives in
+ * the deps. One instance provides `ctx.subprocess` after the profile patch
+ * disabled the plain subprocess row, like the fs facade.
+ *
+ * @module dsh-hardssh/switch-subprocess
+ */
+
+import { SubprocessRuntime } from '@deepseek-ai/dsh-subprocess'
+import type {
+  SubprocessHandle,
+  SubprocessSpawnSpec,
+  SubprocessTerminalHandle,
+  SubprocessTerminalSpawnSpec,
+} from '@deepseek-ai/dsh-subprocess'
+import type { Context } from '@deepseek-ai/cordis'
+
+/** Route one spawn cwd to a runtime. */
+export interface SwitchSubprocessDeps {
+  local: SubprocessRuntime
+  /** The runtime for a spawn cwd (undefined = local). */
+  worldFor(cwd: string | undefined): SubprocessRuntime
+}
+
+/** Workspace-routing subprocess facade. */
+export class SwitchSubprocessRuntime extends SubprocessRuntime {
+  constructor(ctx: Context, private readonly deps: SwitchSubprocessDeps) {
+    super(ctx)
+  }
+
+  /** The runtime for one spec (by its cwd). */
+  private runtimeFor(cwd: string | undefined): SubprocessRuntime {
+    return this.deps.worldFor(cwd)
+  }
+
+  /** @inheritdoc */
+  resolveExecutable(command: string, env?: Readonly<Record<string, string>>, signal?: AbortSignal): Promise<string> {
+    // Executable resolution is not cwd-scoped; route by the caller's cwd is
+    // impossible here, so use the local runtime (bare PATH names on remote
+    // hosts are resolved inside the remote command anyway). Local-only
+    // resolution keeps `command -v` semantics on this machine.
+    return this.deps.local.resolveExecutable(command, env, signal)
+  }
+
+  /** @inheritdoc */
+  spawn(spec: SubprocessSpawnSpec): SubprocessHandle {
+    return this.runtimeFor(spec.cwd).spawn(spec)
+  }
+
+  /** @inheritdoc */
+  spawnTerminal(spec: SubprocessTerminalSpawnSpec): Promise<SubprocessTerminalHandle> {
+    return this.runtimeFor(spec.cwd).spawnTerminal(spec)
+  }
+}
+
+export default SwitchSubprocessRuntime

package/src/tools.ts

@@ -0,0 +1,221 @@
+/**
+ * Agent tools: the remote-workspace counterpart of the local fs tools. Every
+ * tool is bound to the SSH workspace OF THE CALLING SESSION: the tool's
+ * `exec` carries `agent.session.header.cwd` (the session's workspace), which
+ * the ledger resolves to a bound SSH workspace (alias + remote root). A
+ * session in a local workspace gets a clear "this workspace is not SSH-bound"
+ * error; sessions in SSH-bound workspaces operate on the remote host.
+ *
+ * Plain file operations (read / write / edit / mkdir / rm / rename) are NOT
+ * duplicated here: the fs seam routes them automatically by the session cwd
+ * (SFTP on the remote host). This surface keeps only the tools the seam does
+ * not cover: status (self-description), directory listing, and search.
+ *
+ * @module dsh-hardssh/tools
+ */
+import { defineTool } from '@deepseek-ai/dsh-tools'
+import type { ContentBlock } from '@deepseek-ai/dsh-llm'
+import type { ToolRunContext } from '@deepseek-ai/dsh-tools'
+import type { SshEngine } from './ssh/engine.ts'
+import { isInside } from './backend.ts'
+import { RemoteSearchService } from './remote-search.ts'
+import type { SshWorkspaceLedger } from './ledger.ts'
+import type { SshWorkspaceRecord } from './protocol.ts'
+
+/** One text content block (the only render shape these tools emit). */
+function text(value: string): ContentBlock[] {
+  return [{ type: 'text', text: value }]
+}
+
+/** Tool-set dependencies. */
+export interface WorkspaceToolsDeps {
+  engine: SshEngine
+  ledger: SshWorkspaceLedger
+  search: RemoteSearchService
+}
+
+/** Failure envelope shared by every tool. */
+interface ToolFailure {
+  ok: false
+  error: string
+}
+
+/** The SSH bound workspace for the calling session's cwd. */
+function boundWorkspace(ledger: SshWorkspaceLedger, exec: ToolRunContext): Promise<SshWorkspaceRecord | undefined> {
+  const cwd = exec.agent?.session?.header?.cwd
+  if (cwd === undefined || cwd === '') return Promise.resolve(undefined)
+  return ledger.findByAnchor(cwd)
+}
+
+/** True when `abs` is inside (or equals) the remote root. */
+function insideRoot(root: string, abs: string): boolean {
+  return isInside(root, abs)
+}
+
+/** Build every remote_* tool (registered by the host half). */
+export function makeWorkspaceTools(deps: WorkspaceToolsDeps) {
+  const { engine, ledger, search } = deps
+
+  /** The bound workspace for this call, or a failure when the session's
+   *  workspace is not SSH-bound. */
+  const bound = async (exec: ToolRunContext): Promise<{ workspace: SshWorkspaceRecord } | ToolFailure> => {
+    const workspace = await boundWorkspace(ledger, exec)
+    if (workspace === undefined) {
+      return { ok: false, error: 'this session\'s workspace is not SSH-bound — create an SSH workspace and open a session in it first' }
+    }
+    return { workspace }
+  }
+
+  /** Gate one absolute remote path to the workspace's remote root. */
+  const gatePath = (workspace: SshWorkspaceRecord, abs: string): string | undefined => {
+    if (!insideRoot(workspace.remoteRoot, abs)) {
+      return `path '${abs}' is outside the remote root '${workspace.remoteRoot}' of workspace '${workspace.title}'`
+    }
+    return undefined
+  }
+
+  /** Run one remote op, catching errors into the failure envelope. */
+  const run = async <T>(operation: () => Promise<T>): Promise<T | ToolFailure> => {
+    try {
+      return await operation()
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return { ok: false, error: message }
+    }
+  }
+
+  return [
+    defineTool({
+      name: 'remote_status',
+      description: 'List the SSH-bound workspaces and report whether the CALLING SESSION\'s workspace is SSH-bound (and to which host/root). Call this before any remote_* tool. Triggers: SSH mode, remote workspace, where am I working, which servers are bound.',
+      parameters: {},
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            ok: { type: 'boolean', required: true },
+            bound: { type: 'boolean', required: true },
+            workspaceTitle: { type: 'string' },
+            alias: { type: 'string' },
+            remoteRoot: { type: 'string' },
+            anchorPath: { type: 'string' },
+            workspaces: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+              id: { type: 'string', required: true }, title: { type: 'string', required: true }, alias: { type: 'string', required: true }, remoteRoot: { type: 'string', required: true }, anchorPath: { type: 'string', required: true },
+            } } },
+            error: { type: 'string' },
+          },
+        },
+        render: (_args, value) => {
+          if (value.ok !== true) return text(`remote_status failed: ${value.error ?? 'unknown error'}`)
+          const list = (value.workspaces ?? []).map((w: { title: string; alias: string; remoteRoot: string; anchorPath: string }) =>
+            `- ${w.title}  (${w.alias} @ ${w.remoteRoot}, anchor ${w.anchorPath})`)
+          const bound = value.bound === true
+            ? `current session: BOUND -> ${value.workspaceTitle ?? ''} (${value.alias ?? ''} @ ${value.remoteRoot ?? ''})`
+            : 'current session: NOT bound (this workspace is local)'
+          return text([bound, '', 'SSH workspaces:', ...(list.length > 0 ? list : ['(none)'])].join('\n'))
+        },
+      },
+      async execute(_args, exec) {
+        const workspaces = await ledger.list()
+        const workspace = await boundWorkspace(ledger, exec)
+        return {
+          ok: true,
+          bound: workspace !== undefined,
+          workspaceTitle: workspace?.title,
+          alias: workspace?.alias,
+          remoteRoot: workspace?.remoteRoot,
+          anchorPath: workspace?.anchorPath,
+          workspaces: workspaces.map((w) => ({ id: w.id, title: w.title, alias: w.alias, remoteRoot: w.remoteRoot, anchorPath: w.anchorPath })),
+        }
+      },
+    }),
+
+    defineTool({
+      name: 'remote_ls',
+      description: 'List a directory on the SSH host bound to the CALLING SESSION\'s workspace (the path must be inside that workspace\'s remote root). Triggers: list remote directory, remote files, ls on the server.',
+      parameters: {
+        path: { type: 'string', required: true, description: 'Absolute remote directory path inside the workspace\'s remote root (e.g. /home/user/project/src).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            ok: { type: 'boolean', required: true },
+            path: { type: 'string' },
+            entries: { type: 'array', items: { type: 'object', additionalProperties: false, properties: {
+              name: { type: 'string', required: true }, type: { type: 'string', required: true }, size: { type: 'integer', required: true }, mtimeMs: { type: 'integer', required: true },
+            } } },
+            error: { type: 'string' },
+          },
+        },
+        render: (_args, value) => {
+          if (value.ok !== true) return text(`remote_ls failed: ${value.error ?? 'unknown error'}`)
+          const rows = (value.entries ?? []).map((entry: { name: string; type: string; size: number }) =>
+            `${entry.type === 'dir' ? 'dir ' : 'file'} ${entry.name}${entry.type === 'file' ? ` (${entry.size} bytes)` : ''}`)
+          return text([`${value.path}`, ...(rows.length > 0 ? rows : ['(empty)'])].join('\n'))
+        },
+      },
+      async execute(args, exec) {
+        const check = await bound(exec)
+        if ('error' in check) return check
+        const gate = gatePath(check.workspace, args.path)
+        if (gate !== undefined) return { ok: false, error: gate }
+        return run(async () => {
+          const entries = await engine.ls(check.workspace.alias, args.path)
+          return { ok: true, path: args.path, entries: entries.map((entry) => ({ name: entry.name, type: entry.type, size: entry.size, mtimeMs: entry.mtimeMs })) }
+        })
+      },
+    }),
+
+    defineTool({
+      name: 'remote_search',
+      description: 'Search the SSH workspace bound to the CALLING SESSION. mode="glob" matches FILE NAMES by pattern (root-relative, e.g. src/**/*.ts or *.log; max depth 6, capped at 200 hits); mode="grep" searches file CONTENTS for a FIXED STRING (not a regex; skips .git and node_modules; capped at 200 matches per file and 200KB of output). Triggers: find remote files by pattern, glob on the server, grep remote code, search remote contents.',
+      parameters: {
+        mode: { type: 'string', enum: ['glob', 'grep'], required: true, description: 'glob = match file names by pattern; grep = search file contents for a fixed string.' },
+        pattern: { type: 'string', required: true, description: 'glob: root-relative pattern like src/**/*.ts or *.log; grep: the literal text to find (not a regular expression).' },
+      },
+      output: {
+        schema: {
+          type: 'object',
+          additionalProperties: false,
+          properties: {
+            ok: { type: 'boolean', required: true },
+            mode: { type: 'string' },
+            hits: { type: 'array', items: { type: 'string' } },
+            lines: { type: 'array', items: { type: 'string' } },
+            truncated: { type: 'boolean' },
+            error: { type: 'string' },
+          },
+        },
+        render: (_args, value) => {
+          if (value.ok !== true) return text(`remote_search failed: ${value.error ?? 'unknown error'}`)
+          const tail = value.truncated === true
+            ? value.mode === 'grep' ? '\n[output truncated at 200KB]' : '\n[truncated at 200 hits]'
+            : ''
+          const body = value.mode === 'grep' ? (value.lines ?? []) : (value.hits ?? [])
+          return text(body.length > 0 ? body.join('\n') + tail : '(no matches)')
+        },
+      },
+      async execute(args, exec) {
+        const check = await bound(exec)
+        if ('error' in check) return check
+        return run(async () => {
+          if (args.mode === 'grep') {
+            const found = await search.grepFixed(
+              { alias: check.workspace.alias, root: check.workspace.remoteRoot },
+              args.pattern,
+            )
+            return { ok: true, mode: 'grep', lines: found.lines, hits: [], truncated: found.truncated }
+          }
+          const found = await search.glob(
+            { alias: check.workspace.alias, root: check.workspace.remoteRoot },
+            args.pattern,
+          )
+          return { ok: true, mode: 'glob', hits: found.hits, lines: [], truncated: found.truncated }
+        })
+      },
+    }),
+  ]
+}