@tiphareth/dsh-hardssh 0.1.2 → 0.2.2

package/src/remote/remote-terminal.ts

@@ -14,13 +14,17 @@ import type {
   SubprocessTerminalSpawnSpec,
 } from '@deepseek-ai/dsh-subprocess'
 import type { WorkspaceState } from '../protocol.ts'
-import { quoteShellArg, readScrubbedRemoteEnvironment, serializeEnvironment } from './environment.ts'
+import { quoteShellArg, serializeEnvironment } from './environment.ts'
 
 /** Resolve after one duration. */
 function delay(ms: number): Promise<void> {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
 
+/** How long to wait for the login shell's first output before typing anyway.
+ *  A silent shell (unusual for an interactive login) must not hang the tab. */
+const TERMINAL_READY_TIMEOUT_MS = 750
+
 /** One SSH PTY and its remote login shell, projected onto the subprocess terminal seam. */
 export class SshTerminalHandle implements SubprocessTerminalHandle {
   readonly pid = -1
@@ -77,6 +81,17 @@ export class SshTerminalHandle implements SubprocessTerminalHandle {
     return cleanup
   }
 
+  /** Immediately release the channel when the owning runtime's independent
+   * disposal deadline expires. This also settles output/done if ssh2 never
+   * reports a terminal exit after close(). */
+  forceClose(): void {
+    if (this.topLevelExited) return
+    try { this.closeChannel() } catch { /* channel already closed */ }
+    this.topLevelExited = true
+    this.output.end()
+    this.resolveExit({ exitCode: null, signal: null })
+  }
+
   private signal(name: string): void {
     try {
       this.signalChannel(name)
@@ -115,27 +130,97 @@ export async function spawnSshTerminal(
   if (state.mode !== 'remote' || state.alias === undefined) {
     throw new Error('subprocess-ssh: not in remote mode — switch the GUI to SSH mode first')
   }
-  const environment = serializeEnvironment(await readScrubbedRemoteEnvironment(engine, state.alias), spec.env)
-  const session = await engine.openShell(state.alias, { cols: spec.cols, rows: spec.rows })
   const root = state.remoteRoot
   if (root === undefined) throw new Error('subprocess-ssh: remote workspace root is not set')
-  const cwd = spec.cwd !== undefined && spec.cwd.startsWith('/') ? spec.cwd : root
-  const handle = new SshTerminalHandle(
-    () => session.close(),
-    (data) => session.send(data),
-    (name) => session.signal(name),
-    spec.graceMs,
-  )
-  session.onData = (data: Buffer) => {
-    if (!handle.output.destroyed) handle.output.write(data)
-  }
-  session.onExit = (code: number | null, error?: string) => {
-    handle.topLevelExited = true
-    handle.output.end()
-    handle.resolveExit({ exitCode: error !== undefined ? null : code, signal: null })
+  const session = await engine.openShell(state.alias, { cols: spec.cols, rows: spec.rows })
+  let handedOff = false
+  let readyTimer: NodeJS.Timeout | undefined
+  let removeAbortListener = (): void => {}
+  try {
+    // Everything after openShell() is setup owned by this function. Until the
+    // handle is successfully returned, every validation/setup/abort failure
+    // must close the standalone channel rather than orphaning its connection.
+    spec.signal?.throwIfAborted()
+    const cwd = spec.cwd !== undefined && spec.cwd.startsWith('/') ? spec.cwd : root
+    const handle = new SshTerminalHandle(
+      () => session.close(),
+      (data) => session.send(data),
+      (name) => session.signal(name),
+      spec.graceMs,
+    )
+    // Resolves on the login shell's first output (banner/prompt) or the bound:
+    // typing the session command before the shell is reading makes the terminal
+    // echo it twice — once into the banner, once when readline redraws its input.
+    let shellReady: () => void = () => {}
+    const ready = new Promise<void>((resolve) => { shellReady = resolve })
+    readyTimer = setTimeout(() => { shellReady() }, TERMINAL_READY_TIMEOUT_MS)
+    readyTimer.unref?.()
+    let sawOutput = false
+    session.onData = (data: Buffer) => {
+      if (!sawOutput) {
+        sawOutput = true
+        if (readyTimer !== undefined) clearTimeout(readyTimer)
+        shellReady()
+      }
+      if (handle.output.destroyed) return
+      // Leak guard: a remote terminal stream reaches the model through this
+      // capability, so it passes the same engine redactor the exec paths use
+      // (exact-match over known secrets; best-effort, like the PTY route).
+      // Engine doubles without a redactor stream through unchanged.
+      if (typeof engine.redact !== 'function') {
+        handle.output.write(data)
+        return
+      }
+      const text = data.toString('utf8')
+      const safe = engine.redact(text)
+      handle.output.write(safe === text ? data : Buffer.from(safe, 'utf8'))
+    }
+    session.onExit = (code: number | null, error?: string) => {
+      if (readyTimer !== undefined) clearTimeout(readyTimer)
+      shellReady()
+      if (handle.topLevelExited) return
+      handle.topLevelExited = true
+      handle.output.end()
+      handle.resolveExit({ exitCode: error !== undefined ? null : code, signal: null })
+    }
+    const argv = spec.argv.map(quoteShellArg).join(' ')
+    // The PTY IS the remote login shell, so it already carries the remote's own
+    // environment (HOME, PATH, the site's profile.d variables). Rebuilding that
+    // environment into one command line is both redundant and fragile. Apply
+    // ONLY the explicit overlay with `env` (not `env -i`) so the inherited login
+    // environment stays intact.
+    const overlay = serializeEnvironment(new Map(), spec.env)
+    const prefix = overlay === '' ? '' : `env ${overlay} `
+
+    let readyOrAbort: Promise<void> = ready
+    if (spec.signal !== undefined) {
+      const signal = spec.signal
+      const aborted = new Promise<never>((_resolve, reject) => {
+        const onAbort = (): void => {
+          reject(signal.reason instanceof Error
+            ? signal.reason
+            : Object.assign(new Error('terminal setup aborted'), { name: 'AbortError' }))
+        }
+        signal.addEventListener('abort', onAbort, { once: true })
+        removeAbortListener = () => { signal.removeEventListener('abort', onAbort) }
+        if (signal.aborted) onAbort()
+      })
+      readyOrAbort = Promise.race([ready, aborted])
+    }
+    await readyOrAbort
+    removeAbortListener()
+    removeAbortListener = () => {}
+    if (readyTimer !== undefined) clearTimeout(readyTimer)
+    spec.signal?.throwIfAborted()
+    await handle.write(`cd ${quoteShellArg(cwd)} && exec ${prefix}${argv}\r`)
+    spec.signal?.throwIfAborted()
+    handedOff = true
+    return handle
+  } finally {
+    removeAbortListener()
+    if (readyTimer !== undefined) clearTimeout(readyTimer)
+    if (!handedOff) {
+      try { session.close() } catch { /* best-effort close after failed setup */ }
+    }
   }
-  const argv = spec.argv.map(quoteShellArg).join(' ')
-  await handle.write(`cd ${quoteShellArg(cwd)} && exec env -i -- ${environment} ${argv}\r`)
-  spec.signal?.throwIfAborted()
-  return handle
 }

package/src/remote-search.ts

@@ -59,6 +59,97 @@ function sanitizeSearchQuery(query: string): string {
   return query.replace(/\0/g, '').replace(/[\r\n]/g, ' ').slice(0, 128)
 }
 
+/**
+ * Trailer the wrapper appends after the (byte-capped) body: the REAL producer
+ * exit code plus its captured stderr.
+ */
+const STATUS_MARKER = '\0DSH_SEARCH_STATUS:'
+
+/** Minutes after which an abandoned scratch directory is pruned by the next
+ *  search (a SIGKILLed run cannot clean up after itself). */
+const PRUNE_AGE_MINUTES = 10
+
+/** One wrapped command's decomposed output. */
+interface WrappedOutput {
+  /** The producer's stdout, capped at the requested byte budget. */
+  body: string
+  /** The producer's own exit code; undefined when the trailer is absent. */
+  code: number | undefined
+  /** Captured producer stderr (falls back to the engine's stream). */
+  stderr: string
+}
+
+/** Split a wrapped command's stdout into body / producer exit code / stderr. */
+function splitWrappedOutput(stdout: string, fallbackStderr: string): WrappedOutput {
+  const at = stdout.indexOf(STATUS_MARKER)
+  if (at < 0) return { body: stdout, code: undefined, stderr: fallbackStderr }
+  const body = stdout.slice(0, at)
+  const rest = stdout.slice(at + STATUS_MARKER.length)
+  const end = rest.indexOf('\0')
+  const codeText = end < 0 ? rest : rest.slice(0, end)
+  const code = Number.parseInt(codeText, 10)
+  const captured = (end < 0 ? '' : rest.slice(end + 1)).trim()
+  return {
+    body,
+    code: Number.isSafeInteger(code) ? code : undefined,
+    stderr: captured === '' ? fallbackStderr : captured,
+  }
+}
+
+/**
+ * Wrap a producer command so its exit code and stderr survive the output cap.
+ *
+ * Piping into `head -c` made the pipeline report `head`'s status, so a missing
+ * root or a permission failure looked like "success, no matches". The producer
+ * now writes into a temp directory: one `mktemp -d` (a half-failed `mktemp`
+ * pair used to leak the first file), whose removal is registered with `trap`
+ * so a normal exit, SIGINT, SIGTERM or SIGHUP still cleans up.
+ *
+ * `trap` cannot cover SIGKILL — which is exactly how a timed-out command is
+ * ended — so the directory lives under ONE per-user scratch root that each
+ * search prunes of anything older than PRUNE_AGE_MINUTES. A killed run can
+ * therefore leave at most one directory, and no litter accumulates in /tmp.
+ *
+ * @param producer - the command whose stdout/stderr/status must be observed.
+ * @param capBytes - byte budget for the returned body.
+ * @returns one POSIX-sh command string.
+ */
+function wrapWithStatus(producer: string, capBytes: number): string {
+  return [
+    '__dsh_root="${TMPDIR:-/tmp}/dsh-hardssh-search"',
+    'mkdir -p "$__dsh_root" 2>/dev/null',
+    `find "$__dsh_root" -mindepth 1 -maxdepth 1 -mmin +${PRUNE_AGE_MINUTES} -exec rm -rf {} + 2>/dev/null`,
+    '__dsh_dir=$(mktemp -d "$__dsh_root/run.XXXXXX") || { echo "dsh-search: mktemp failed" >&2; exit 90; }',
+    "trap 'rm -rf \"$__dsh_dir\"' EXIT INT TERM HUP",
+    `{ ${producer} ; } >"$__dsh_dir/out" 2>"$__dsh_dir/err"; __dsh_code=$?`,
+    `head -c ${capBytes} "$__dsh_dir/out"`,
+    `printf '\\0DSH_SEARCH_STATUS:%s\\0' "$__dsh_code"`,
+    'head -c 4096 "$__dsh_dir/err"',
+    'exit 0',
+  ].join('; ')
+}
+
+/**
+ * Resolve the producer's exit code, refusing to fall back to the wrapper's own
+ * (successful) status when the wrapper died before reporting one.
+ *
+ * The trailer is absent only if the wrapped shell was killed at the hard
+ * deadline. Falling back to the wrapper's exit code there would resurrect the
+ * original "success, no matches" bug for exactly the case that matters.
+ */
+function producerExitCode(wrapped: WrappedOutput, wrapperExitCode: number | null): number {
+  if (wrapped.code !== undefined) return wrapped.code
+  // The engine reports a null exit code for a signal-killed process; that is a
+  // failure too, so normalise it before deciding.
+  const fallback = wrapperExitCode ?? 0
+  if (wrapped.body === '' && fallback === 0) {
+    throw new Error(wrapped.stderr.trim() !== ''
+      ? wrapped.stderr.trim()
+      : 'remote search did not report a result status (the search shell was terminated)')
+  }
+  return fallback
+}
+
 /** Escape find `-iname` metacharacters so user input matches literally. */
 function escapeFindLiteral(value: string): string {
   return value.replace(/[*?[\]\\]/g, '\\$&')
@@ -85,25 +176,27 @@ 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> {
+  async searchNames(target: SearchTarget, query: string, signal?: AbortSignal): Promise<RemoteNameSearch> {
     const literal = sanitizeSearchQuery(query)
     if (literal === '') return { query, hits: [], truncated: false }
     const pattern = escapeFindLiteral(literal)
-    const command =
+    const producer =
       `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 result = await this.engine.exec(target.alias, wrapWithStatus(producer, OUTPUT_CAP_BYTES), { timeoutMs: SEARCH_TIMEOUT_MS, signal })
+    const { body, code, stderr } = splitWrappedOutput(result.stdout, result.stderr)
+    const effective = producerExitCode({ body, code, stderr }, result.exitCode)
+    // An empty body with a failing producer is a real failure (missing root,
+    // permission denied), never "success, no matches".
+    if (body === '' && effective !== 0) {
+      throw new Error(stderr.trim() !== '' ? stderr.trim() : `remote search failed with exit code ${effective}`)
     }
-    const allHits = parseNameRecords(result.stdout)
-    const capped = Buffer.byteLength(result.stdout, 'utf8') >= OUTPUT_CAP_BYTES
+    const allHits = parseNameRecords(body)
+    const capped = Buffer.byteLength(body, 'utf8') >= OUTPUT_CAP_BYTES
     return {
       query,
       hits: allHits.slice(0, SEARCH_HIT_CAP),
@@ -112,40 +205,43 @@ export class RemoteSearchService {
   }
 
   /** Glob search (pattern keeps glob semantics; `**` crosses directories). */
-  async glob(target: SearchTarget, pattern: string): Promise<RemoteGlobResult> {
+  async glob(target: SearchTarget, pattern: string, signal?: AbortSignal): Promise<RemoteGlobResult> {
     const relative = pattern.replace(/^\/+/, '')
-    const command =
+    const producer =
       `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
+    const result = await this.engine.exec(target.alias, wrapWithStatus(producer, OUTPUT_CAP_BYTES), { timeoutMs: SEARCH_TIMEOUT_MS, signal })
+    const { body, code, stderr } = splitWrappedOutput(result.stdout, result.stderr)
+    const effective = producerExitCode({ body, code, stderr }, result.exitCode)
+    if (body === '' && effective !== 0) {
+      throw new Error(stderr.trim() !== '' ? stderr.trim() : `remote glob failed with exit code ${effective}`)
+    }
+    const hits = body.split('\0').filter((path) => path !== '')
+    const capped = Buffer.byteLength(body, '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> {
+  async grepFixed(target: SearchTarget, pattern: string, signal?: AbortSignal): Promise<RemoteGrepResult> {
     if (pattern.includes('\0')) return { lines: [], truncated: false }
-    const command =
+    const producer =
       `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)
+    const result = await this.engine.exec(target.alias, wrapWithStatus(producer, GREP_CAP_BYTES), { timeoutMs: SEARCH_TIMEOUT_MS, signal })
+    const { body, code, stderr } = splitWrappedOutput(result.stdout, result.stderr)
+    const effective = producerExitCode({ body, code, stderr }, result.exitCode)
     // 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())
+    if (body === '' && effective === 1) return { lines: [], truncated: false }
+    if (body === '' && effective !== 0) {
+      throw new Error(stderr.trim() !== '' ? stderr.trim() : `remote grep failed with exit code ${effective}`)
     }
     // -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')) {
+    for (const line of body.split('\n')) {
       if (line === '') continue
       const nul = line.indexOf('\0')
       if (nul >= 0) {
@@ -157,7 +253,7 @@ export class RemoteSearchService {
         lines.push(line)
       }
     }
-    const capped = Buffer.byteLength(result.stdout, 'utf8') >= GREP_CAP_BYTES
+    const capped = Buffer.byteLength(body, 'utf8') >= GREP_CAP_BYTES
     return { lines, truncated: capped }
   }
 }