@tiphareth/dsh-hardssh 0.1.2

package/src/remote-runner.ts

@@ -0,0 +1,201 @@
+/**
+ * Remote-workspace runner: lets other plugins (dsh-workbench-tiphareth) run
+ * git/files/terminals against an SSH-bound workspace. The workbench host asks
+ * `resolveRemote(root)` for a local anchor path; a hit returns the remote
+ * context + callable channels (git exec via the engine, SFTP ops, PTY).
+ * Kept duck-typed so the workbench never needs a compile-time dependency.
+ */
+
+import type { SshEngine } from './ssh/engine.ts'
+import type { SshWorkspaceLedger } from './ledger.ts'
+
+/** The remote context one SSH-bound workspace resolves to. */
+export interface RemoteWorkspaceContext {
+  alias: string
+  remoteRoot: string
+  /** Run `git [args...]` inside remoteRoot. Mirrors runGit's result shape. */
+  git(args: readonly string[], opts?: { timeoutMs?: number; input?: string; allowNonZero?: boolean }): Promise<{ stdout: string; stderr: string; exitCode: number }>
+  /** Run one arbitrary command (used by tools that shell out). */
+  run(command: string, opts?: { timeoutMs?: number }): Promise<{ stdout: string; stderr: string; exitCode: number }>
+  /** SFTP operations. */
+  list(path: string): Promise<Array<{ name: string; type: 'dir' | 'file' | 'other'; size: number; mtimeMs: number }>>
+  stat(path: string): Promise<{ type: 'dir' | 'file' | 'other'; size: number; mtimeMs: number; mode: number }>
+  readFile(path: string): Promise<{ content: Buffer; mtime: number; size: number }>
+  writeFile(path: string, content: Buffer, expectedMtime?: number): Promise<{ mtime: number }>
+  mkdir(path: string): Promise<void>
+  rm(path: string, recursive: boolean): Promise<void>
+  rename(from: string, to: string): Promise<void>
+  /** Open an interactive SSH PTY in remoteRoot (columns/rows for the channel). */
+  openTerminal(cols: number, rows: number): Promise<RemotePtyHandle>
+}
+
+/** Minimal PTY handle (duck-typed for consumers like dsh-workbench-tiphareth). */
+export interface RemotePtyHandle {
+  shell: string
+  write(data: string): void
+  resize(cols: number, rows: number): void
+  kill(): void
+  onData(handler: (data: string) => void): { dispose(): void }
+  onExit(handler: (event: { exitCode: number }) => void): { dispose(): void }
+}
+
+/** Last-resort bound on opening a remote PTY (fresh SSH connect + shell). */
+const OPEN_SHELL_TIMEOUT_MS = 30_000
+
+/** Reject `promise` after `ms` with a clear message (unref'd timer). */
+function withTimeout<T>(promise: Promise<T>, ms: number, message: string): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms)
+    timer.unref?.()
+    promise.then(
+      (value) => { clearTimeout(timer); resolve(value) },
+      (error) => { clearTimeout(timer); reject(error) },
+    )
+  })
+}
+
+/** Builds remote-workspace contexts off the shared ledger + engine. */
+export class RemoteWorkspaceRunner {
+  constructor(
+    private readonly engine: SshEngine,
+    private readonly ledger: SshWorkspaceLedger,
+  ) {}
+
+  /** Resolve a LOCAL anchor path to a remote context, or null if not SSH-bound. */
+  resolveRemote(root: string): RemoteWorkspaceContext | null {
+    const record = this.ledger.findByAnchorSync(root)
+    if (record === undefined) return null
+    return this.build(record.alias, record.remoteRoot)
+  }
+
+  private build(alias: string, remoteRoot: string): RemoteWorkspaceContext {
+    const engine = this.engine
+    const git = async (
+      args: readonly string[],
+      opts: { timeoutMs?: number; input?: string; allowNonZero?: boolean } = {},
+    ): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+      const quoted = args.map(arg => quote(arg)).join(' ')
+      // Restore real stderr ordering by capturing both streams; the engine
+      // exec returns them merged per frame — keep them merged for git too.
+      const command = `git ${quoted}`
+      const result = await engine.exec(alias, `cd ${quote(remoteRoot)} && ${command}`, opts.timeoutMs)
+      const stdout = result.stdout
+      const stderr = result.stderr
+      const exitCode = result.exitCode ?? 1
+      if (exitCode !== 0 && opts.allowNonZero !== true) {
+        const err = new Error(stderr.trim() || `git exited ${exitCode}`)
+        ;(err as { shortMessage?: string }).shortMessage = stderr.trim()
+        throw err
+      }
+      return { stdout, stderr, exitCode }
+    }
+    const run = async (
+      command: string,
+      opts: { timeoutMs?: number } = {},
+    ): Promise<{ stdout: string; stderr: string; exitCode: number }> => {
+      const result = await engine.exec(alias, `cd ${quote(remoteRoot)} && ${command}`, opts.timeoutMs)
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode ?? 1,
+      }
+    }
+    const list = async (path: string): Promise<Array<{ name: string; type: 'dir' | 'file' | 'other'; size: number; mtimeMs: number }>> => {
+      return engine.ls(alias, path)
+    }
+    const stat = async (path: string): Promise<{ type: 'dir' | 'file' | 'other'; size: number; mtimeMs: number; mode: number }> => {
+      return engine.stat(alias, path)
+    }
+    const readFile = async (path: string): Promise<{ content: Buffer; mtime: number; size: number }> => {
+      return engine.readFile(alias, path)
+    }
+    const writeFile = async (path: string, content: Buffer, expectedMtime?: number): Promise<{ mtime: number }> => {
+      return engine.writeFile(alias, path, content, expectedMtime)
+    }
+    const mkdir = async (path: string): Promise<void> => { await engine.mkdir(alias, path) }
+    const rm = async (path: string, recursive: boolean): Promise<void> => { await engine.rm(alias, path, recursive) }
+    const rename = async (from: string, to: string): Promise<void> => { await engine.rename(alias, from, to) }
+    const openTerminal = async (cols: number, rows: number): Promise<RemotePtyHandle> => {
+      // Bound the shell open: the engine's own connect/channel timeouts cover
+      // the normal failure modes, this is a last-resort guard so a terminal
+      // request can never hang the workbench's SSE stream indefinitely.
+      const session = await withTimeout(
+        engine.openShell(alias, { cols, rows }),
+        OPEN_SHELL_TIMEOUT_MS,
+        `SSH 终端打开超时（${OPEN_SHELL_TIMEOUT_MS / 1000} 秒）：${alias}`,
+      )
+      let exited = false
+      const exitHandlers = new Set<(event: { exitCode: number }) => void>()
+      const onDataHandlers = new Set<(data: string) => void>()
+      const enc = new TextDecoder()
+
+      // The PTY already runs the user's interactive login shell (client.shell
+      // allocates one); just cd into the remote root. Do NOT exec a new shell
+      // here — that restarts the shell, re-runs profile/.bashrc, and replays
+      // the login banner + prompt (the "command ran twice" symptom).
+      //
+      // Send `cd` only AFTER the first shell prompt has been emitted — a
+      // prompt (line ending in $ / # / > / %) means the login banner finished
+      // and the shell is interactive. Sending earlier makes the PTY echo the
+      // command raw AND the shell re-echo it after the prompt (double cd).
+      let cwdSent = false
+      let shellBuf = ''
+      const trySendCwd = (): void => {
+        if (cwdSent || exited) return
+        // Prompt heuristic: the last non-empty line ends with a prompt char
+        // (`$ # > %`) OR looks like a user@host prompt (e.g. `@login01 ~`,
+        // `majie@host:~/dir$`). Either means the shell is interactive now.
+        const lines = shellBuf.split('\n').map(line => line.replace(/\r$/, '')).filter(line => line.trim() !== '')
+        const last = lines[lines.length - 1]
+        if (last !== undefined
+          && ( /[#$>%]\s*$/.test(last) || /^\S+@\S+/.test(last) )
+          && !last.trim().endsWith('cd')) {
+          cwdSent = true
+          session.send(`cd ${quote(remoteRoot)}\r`)
+        }
+      }
+      session.onData = (data: Buffer) => {
+        const text = enc.decode(data)
+        shellBuf = (shellBuf + text).slice(-4096)
+        trySendCwd()
+        for (const handler of onDataHandlers) handler(text)
+      }
+      session.onExit = (code: number | null) => {
+        exited = true
+        for (const handler of exitHandlers) handler({ exitCode: code ?? -1 })
+      }
+      // Fallback: if no prompt heuristic matched (odd PS1), send cd after 4s.
+      setTimeout(() => {
+        if (!cwdSent && !exited) {
+          cwdSent = true
+          session.send(`cd ${quote(remoteRoot)}\r`)
+        }
+      }, 4000)
+      return {
+        shell: 'ssh',
+        write(data: string) { if (!exited) session.send(data) },
+        resize(c: number, r: number) { session.resize(c, r) },
+        kill() {
+          try { session.signal('KILL') } catch { /* closed */ }
+          try { session.close() } catch { /* closed */ }
+        },
+        onData(handler: (data: string) => void) {
+          onDataHandlers.add(handler)
+          return { dispose: () => { onDataHandlers.delete(handler) } }
+        },
+        onExit(handler: (event: { exitCode: number }) => void) {
+          exitHandlers.add(handler)
+          return { dispose: () => { exitHandlers.delete(handler) } }
+        },
+      }
+    }
+    return { alias, remoteRoot, git, run, list, stat, readFile, writeFile, mkdir, rm, rename, openTerminal }
+  }
+}
+
+/** POSIX single-quote a shell argument. */
+function quote(arg: string): string {
+  if (arg === '') return "''"
+  if (/^[a-zA-Z0-9_\-./:=@]+$/.test(arg)) return arg
+  return `'${arg.replace(/'/g, `'\\''`)}'`
+}

package/src/remote-search.ts

@@ -0,0 +1,163 @@
+/**
+ * Remote search semantics shared by the UI file-name search (backend) and the
+ * remote_search agent tool (glob / grep modes). Centralizes command building,
+ * literal escaping, NUL-delimited parsing, and truncation rules (P1-11) so
+ * the three former hand-rolled implementations cannot drift again.
+ *
+ * Command output is never treated as authorization evidence: this service
+ * returns raw absolute paths; callers (backend) re-authorize each hit against
+ * the workspace root before exposing it.
+ */
+
+import type { SshEngine } from './ssh/engine.ts'
+import { shellQuote } from './shell.ts'
+
+/** One SSH workspace to search on. */
+export interface SearchTarget {
+  alias: string
+  /** Remote root; every path is reported absolute under it. */
+  root: string
+}
+
+/** One raw file-name hit (absolute path, type). */
+export interface RemoteNameHit {
+  path: string
+  isDir: boolean
+}
+
+export interface RemoteNameSearch {
+  query: string
+  hits: RemoteNameHit[]
+  truncated: boolean
+}
+
+export interface RemoteGlobResult {
+  hits: string[]
+  truncated: boolean
+}
+
+export interface RemoteGrepResult {
+  lines: string[]
+  truncated: boolean
+}
+
+/** File-name search depth (matches the pre-existing backend budget). */
+const SEARCH_MAX_DEPTH = 4
+/** Glob search depth (matches the pre-existing glob-search budget). */
+const GLOB_MAX_DEPTH = 6
+/** Max hits returned by any search. */
+const SEARCH_HIT_CAP = 200
+/** Per-search engine timeout. */
+const SEARCH_TIMEOUT_MS = 20_000
+/** Raw-output cap for name/glob searches (defensive; parsing decides truncation). */
+const OUTPUT_CAP_BYTES = 256 * 1024
+/** Raw-output cap for grep (the tool contract's 200KB budget). */
+const GREP_CAP_BYTES = 200_000
+
+/** Strip control characters and cap the query length (wire hygiene). */
+function sanitizeSearchQuery(query: string): string {
+  return query.replace(/\0/g, '').replace(/[\r\n]/g, ' ').slice(0, 128)
+}
+
+/** Escape find `-iname` metacharacters so user input matches literally. */
+function escapeFindLiteral(value: string): string {
+  return value.replace(/[*?[\]\\]/g, '\\$&')
+}
+
+/** Parse NUL-delimited `type\0path\0...` records from `find -printf`. */
+function parseNameRecords(stdout: string): RemoteNameHit[] {
+  const parts = stdout.split('\0')
+  const hits: RemoteNameHit[] = []
+  for (let i = 0; i + 1 < parts.length; i += 2) {
+    const type = parts[i]
+    const abs = parts[i + 1]
+    if (type === undefined || abs === undefined || abs === '') continue
+    hits.push({ path: abs, isDir: type === 'd' })
+  }
+  return hits
+}
+
+/**
+ * One search implementation shared by the UI and the agent tools.
+ * Stateless apart from the engine; safe to construct per call or share.
+ */
+export class RemoteSearchService {
+  constructor(private readonly engine: SshEngine) {}
+
+  /** Literal file-name search under `root` (skips node_modules/.git). */
+  async searchNames(target: SearchTarget, query: string): Promise<RemoteNameSearch> {
+    const literal = sanitizeSearchQuery(query)
+    if (literal === '') return { query, hits: [], truncated: false }
+    const pattern = escapeFindLiteral(literal)
+    const command =
+      `find ${shellQuote(target.root)}`
+      + ` -maxdepth ${SEARCH_MAX_DEPTH}`
+      + ` -not -path ${shellQuote('*/node_modules/*')}`
+      + ` -not -path ${shellQuote('*/.git/*')}`
+      + ` -iname ${shellQuote(`*${pattern}*`)}`
+      + ` -printf '%y\\0%p\\0'`
+      + ` 2>/dev/null`
+      + ` | head -c ${OUTPUT_CAP_BYTES}`
+    const result = await this.engine.exec(target.alias, command, SEARCH_TIMEOUT_MS)
+    if (!result.success && result.stdout === '' && result.stderr !== '') {
+      throw new Error(result.stderr.trim())
+    }
+    const allHits = parseNameRecords(result.stdout)
+    const capped = Buffer.byteLength(result.stdout, 'utf8') >= OUTPUT_CAP_BYTES
+    return {
+      query,
+      hits: allHits.slice(0, SEARCH_HIT_CAP),
+      truncated: allHits.length > SEARCH_HIT_CAP || capped,
+    }
+  }
+
+  /** Glob search (pattern keeps glob semantics; `**` crosses directories). */
+  async glob(target: SearchTarget, pattern: string): Promise<RemoteGlobResult> {
+    const relative = pattern.replace(/^\/+/, '')
+    const command =
+      `find ${shellQuote(target.root)}`
+      + ` -maxdepth ${GLOB_MAX_DEPTH}`
+      + ` -path ${shellQuote(`${target.root}/${relative}`)}`
+      + ` -printf '%p\\0'`
+      + ` 2>/dev/null`
+      + ` | head -c ${OUTPUT_CAP_BYTES}`
+    const result = await this.engine.exec(target.alias, command, SEARCH_TIMEOUT_MS)
+    const hits = result.stdout.split('\0').filter((path) => path !== '')
+    const capped = Buffer.byteLength(result.stdout, 'utf8') >= OUTPUT_CAP_BYTES
+    // Truncation means "there ARE more than the cap", never "== cap".
+    return { hits: hits.slice(0, SEARCH_HIT_CAP), truncated: hits.length > SEARCH_HIT_CAP || capped }
+  }
+
+  /** Fixed-string grep (literal pattern, `-F`; NUL file boundary `-Z`). */
+  async grepFixed(target: SearchTarget, pattern: string): Promise<RemoteGrepResult> {
+    if (pattern.includes('\0')) return { lines: [], truncated: false }
+    const command =
+      `grep -rInFZ --exclude-dir=.git --exclude-dir=node_modules -m 200`
+      + ` -- ${shellQuote(pattern)} ${shellQuote(target.root)}`
+      + ` 2>/dev/null`
+      + ` | head -c ${GREP_CAP_BYTES}`
+    const result = await this.engine.exec(target.alias, command, SEARCH_TIMEOUT_MS)
+    // grep exit 1 = no matches: an empty result, not an error.
+    if (result.exitCode === 1) return { lines: [], truncated: false }
+    if (!result.success && result.stdout === '' && result.stderr !== '') {
+      throw new Error(result.stderr.trim())
+    }
+    // -Z emits `file\0:line` then bare `:line` continuations for the same file.
+    const lines: string[] = []
+    let lastFile: string | undefined
+    for (const line of result.stdout.split('\n')) {
+      if (line === '') continue
+      const nul = line.indexOf('\0')
+      if (nul >= 0) {
+        lastFile = line.slice(0, nul)
+        lines.push(lastFile + line.slice(nul + 1))
+      } else if (lastFile !== undefined && line.startsWith(':')) {
+        lines.push(lastFile + line)
+      } else {
+        lines.push(line)
+      }
+    }
+    const capped = Buffer.byteLength(result.stdout, 'utf8') >= GREP_CAP_BYTES
+    return { lines, truncated: capped }
+  }
+}