@tiphareth/dsh-hardssh 0.1.2-alpha

package/src/remote/environment.ts

@@ -0,0 +1,123 @@
+/**
+ * Remote-environment scrubbing and caching for the SSH process and terminal
+ * launchers. Ported from UynajGI/dsh-ssh (MIT) — adapted to the dsh-ssh
+ * engine. The read side is cached per (engine, alias) with a short TTL and
+ * merged concurrent requests, so repeated spawns/terminals on one host stop
+ * issuing an `env` exec each time (P1-12).
+ */
+
+import { SENSITIVE_ENV_PATTERN } from '@deepseek-ai/dsh-subprocess'
+import type { SshEngine } from '../ssh/engine.ts'
+import { shellQuote as quoteShellArg } from '../shell.ts'
+
+/** Quote one argument for a POSIX login shell (canonical implementation in shell.ts). */
+export { quoteShellArg }
+/** Wrap a remote command so it runs from the given working directory. */
+export function wrapCwd(cwd: string, command: string): string {
+  return `cd -- ${quoteShellArg(cwd)} && ${command}`
+}
+
+/** How long a scrubbed environment stays fresh per alias. */
+const ENVIRONMENT_TTL_MS = 30_000
+
+/** One cache entry: a settled value (until expiry) or an in-flight promise. */
+interface EnvironmentCacheEntry {
+  expiresAt: number
+  value?: ReadonlyMap<string, string>
+  pending?: Promise<ReadonlyMap<string, string>>
+}
+
+/** Per-engine alias caches (WeakMap so engines are collected with the pool). */
+const caches = new WeakMap<SshEngine, Map<string, EnvironmentCacheEntry>>()
+
+function cacheFor(engine: SshEngine): Map<string, EnvironmentCacheEntry> {
+  let byAlias = caches.get(engine)
+  if (byAlias === undefined) {
+    byAlias = new Map()
+    caches.set(engine, byAlias)
+  }
+  return byAlias
+}
+
+/**
+ * Read + scrub the remote login environment, cached per (engine, alias).
+ * Concurrent requests share one fetch; failures are never cached.
+ */
+export function readScrubbedRemoteEnvironment(
+  engine: SshEngine,
+  alias: string,
+): Promise<ReadonlyMap<string, string>> {
+  const byAlias = cacheFor(engine)
+  const now = Date.now()
+  const existing = byAlias.get(alias)
+  if (existing !== undefined && existing.expiresAt > now && existing.value !== undefined) {
+    return Promise.resolve(existing.value)
+  }
+  if (existing?.pending !== undefined) return existing.pending
+  const pending = fetchScrubbedEnvironment(engine, alias).then(
+    (value) => {
+      byAlias.set(alias, { expiresAt: Date.now() + ENVIRONMENT_TTL_MS, value })
+      return value
+    },
+    (error: unknown) => {
+      // A failed read must not poison the cache: drop it so the next call retries.
+      byAlias.delete(alias)
+      throw error
+    },
+  )
+  byAlias.set(alias, { expiresAt: 0, pending })
+  return pending
+}
+
+/** Drop cached environments for one alias (call after a host config change). */
+export function invalidateRemoteEnvironment(engine: SshEngine, alias: string): void {
+  cacheFor(engine).delete(alias)
+}
+
+/** One `env -0` round-trip, scrubbed (NUL-delimited so values keep newlines/=). */
+async function fetchScrubbedEnvironment(engine: SshEngine, alias: string): Promise<ReadonlyMap<string, string>> {
+  const result = await engine.exec(alias, 'env -0', 10_000)
+  if (!result.success) {
+    throw new Error(`subprocess-ssh: cannot read the remote environment: ${result.stderr.trim() || 'unknown error'}`)
+  }
+  const environment = new Map<string, string>()
+  for (const record of result.stdout.split('\0')) {
+    if (record === '') continue
+    const separator = record.indexOf('=')
+    if (separator <= 0) continue
+    const name = record.slice(0, separator)
+    if (name.includes('\0')) continue
+    environment.set(name, record.slice(separator + 1))
+  }
+  return scrubRemoteEnvironment(environment)
+}
+
+/**
+ * Remove harness-private and credential-shaped names from a remote environment.
+ */
+export function scrubRemoteEnvironment(environment: ReadonlyMap<string, string>): Map<string, string> {
+  const scrubbed = new Map<string, string>()
+  for (const [name, value] of environment) {
+    if (name.startsWith('DSH_') || SENSITIVE_ENV_PATTERN.test(name)) continue
+    scrubbed.set(name, value)
+  }
+  return scrubbed
+}
+
+/**
+ * Overlay explicit entries and serialize one validated environment for `env -i`.
+ */
+export function serializeEnvironment(
+  scrubbed: ReadonlyMap<string, string>,
+  explicit: Readonly<NodeJS.ProcessEnv> | undefined,
+): string {
+  const environment = new Map(scrubbed)
+  for (const [name, value] of Object.entries(explicit ?? {})) {
+    if (name.length === 0 || name.includes('=') || name.includes('\0') || value?.includes('\0') === true) {
+      throw new Error('subprocess-ssh: environment entries require non-empty NUL-free names without = and NUL-free values')
+    }
+    if (value === undefined) environment.delete(name)
+    else environment.set(name, value)
+  }
+  return [...environment].map(([name, value]) => quoteShellArg(`${name}=${value}`)).join(' ')
+}

package/src/remote/output.ts

@@ -0,0 +1,142 @@
+/**
+ * Bounded host-side projection of one remote output stream with a local
+ * spill file. Ported from UynajGI/dsh-ssh (MIT) — verbatim semantics.
+ */
+
+import { randomBytes } from 'node:crypto'
+import { closeSync, mkdtempSync, openSync, unlinkSync, writeSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { CollectedOutput, SubprocessOutputRead, SubprocessOutputReader } from '@deepseek-ai/dsh-subprocess'
+
+let spillCounter = 0
+let defaultSpillDir: string | undefined
+
+/** Private (0700) per-process spill directory under the OS tmpdir, created lazily. */
+function privateSpillDir(): string {
+  defaultSpillDir ??= mkdtempSync(join(tmpdir(), 'dsh-subprocess-ssh-'))
+  return defaultSpillDir
+}
+
+/**
+ * Collects one remote stream with a bounded in-memory tail. On first overflow
+ * a spill file is opened (when a spill cap is configured) and every chunk —
+ * already-collected ones included — is appended there while the full stream
+ * stays within the cap; without one, only the in-memory tail is retained.
+ */
+export class SshOutputCollector implements SubprocessOutputReader {
+  private chunks: Buffer[] = []
+  private retained = 0
+  private total = 0
+  private dropped = false
+  private spillFd: number | undefined
+  private spillFile: string | undefined
+  private spillDisabled: boolean
+
+  constructor(
+    private readonly maxBytes: number,
+    private readonly maxSpillBytes: number | undefined,
+    private readonly label: string,
+    private readonly spillDir: string = privateSpillDir(),
+  ) {
+    this.spillDisabled = maxSpillBytes === undefined
+  }
+
+  /** Append one byte-faithful remote chunk, trimming the retained tail to the cap. */
+  push(chunk: Uint8Array): void {
+    if (chunk.length === 0) return
+    const buffer = Buffer.from(chunk)
+    this.total += buffer.length
+    const overflows = this.retained + buffer.length > this.maxBytes
+    if (!this.spillDisabled && (overflows || this.spillFd !== undefined)) this.spillAll(buffer)
+    this.chunks.push(buffer)
+    this.retained += buffer.length
+    while (this.retained > this.maxBytes) {
+      const head = this.chunks[0] as Buffer
+      const excess = this.retained - this.maxBytes
+      if (head.length <= excess) {
+        this.chunks.shift()
+        this.retained -= head.length
+      } else {
+        this.chunks[0] = head.subarray(excess)
+        this.retained -= excess
+      }
+      this.dropped = true
+    }
+  }
+
+  /** @inheritdoc */
+  readFrom(fromByte: number): SubprocessOutputRead {
+    const retained = Buffer.concat(this.chunks, this.retained)
+    const windowStart = this.total - this.retained
+    const lossy = fromByte < windowStart
+    const start = lossy ? 0 : Math.min(retained.length, Math.max(0, fromByte - windowStart))
+    return {
+      text: retained.subarray(start).toString('utf8'),
+      nextOffset: this.total,
+      lossy,
+      ...(this.spillFile !== undefined ? { spillPath: this.spillFile } : {}),
+    }
+  }
+
+  /** Open the spill file lazily and append one chunk (plus any prior chunks once). */
+  private spillAll(chunk: Buffer): void {
+    if (this.maxSpillBytes !== undefined && this.total > this.maxSpillBytes) {
+      this.discardSpill()
+      return
+    }
+    if (this.spillFd === undefined) {
+      this.spillFile = join(
+        this.spillDir,
+        `dsh-subprocess-ssh-${process.pid}-${++spillCounter}-${randomBytes(6).toString('hex')}-${this.label}.log`,
+      )
+      this.spillFd = openSync(this.spillFile, 'wx', 0o600)
+      for (const prior of this.chunks) writeSync(this.spillFd, prior)
+    }
+    writeSync(this.spillFd, chunk)
+  }
+
+  /** Stop spilling and remove the file once it can no longer hold the complete stream. */
+  private discardSpill(): void {
+    const fd = this.spillFd
+    const file = this.spillFile
+    this.spillFd = undefined
+    this.spillFile = undefined
+    this.spillDisabled = true
+    if (fd !== undefined) {
+      try {
+        closeSync(fd)
+      } catch {
+        this.spillFd = fd
+      }
+    }
+    if (file !== undefined) {
+      try {
+        unlinkSync(file)
+      } catch {
+        // A failed unlink leaves at most maxSpillBytes behind, never an unbounded file.
+      }
+    }
+  }
+
+  /** Close the spill file once the stream has ended; stop advertising it on a failed close. */
+  seal(): void {
+    if (this.spillFd === undefined) return
+    try {
+      closeSync(this.spillFd)
+    } catch {
+      this.spillFile = undefined
+    }
+    this.spillFd = undefined
+  }
+
+  /** Seal the spill and return the final collected output. */
+  finalize(): CollectedOutput {
+    this.seal()
+    return {
+      text: Buffer.concat(this.chunks).toString('utf8'),
+      truncated: this.dropped,
+      ...(this.spillFile !== undefined ? { spillPath: this.spillFile } : {}),
+    }
+  }
+}