dsh-plugin-guide 0.3.42 → 0.4.1

package/references/official-docs/docs/subsystems/subprocess.i18n.yaml

@@ -1,31 +0,0 @@
-# Bilingual-pair consistency record for subprocess.md (docs/i18n/README.md): per heading
-# section, a hash of its English and Chinese blocks outside code blocks and generated regions.
-# After editing either side, bring the other along and re-record with:
-#   pnpm run verify-translation-pairing --write docs/subsystems/subprocess.md
-/subprocess:
-  en: c69213d20e09877f
-  zh: d4a53675e93774d3
-/subprocess/executable-lookup:
-  en: be4ddc71906d893d
-  zh: 49823ef13713dea0
-/subprocess/managed-environment-namespace-and-captured-output:
-  en: 379561c465f061a2
-  zh: 69f62888c5070a91
-/subprocess/node-shaped-stdio-dispositions:
-  en: f591b05b1c765670
-  zh: e39f8bf1a6d02438
-/subprocess/the-fully-explicit-spawn-spec:
-  en: fbbe3aa52c088343
-  zh: 1496fedd080593d3
-/subprocess/handles-streams-readers-and-managed-range-termination:
-  en: 664ba5f23b9da1d9
-  zh: d3eb37a157e50728
-/subprocess/outcomes-carry-exit-facts-only:
-  en: b61bda6c2806b335
-  zh: 0adcb61c5c2af380
-/subprocess/terminal-process-primitive:
-  en: c207221293cfe4d8
-  zh: 3101c861eaa30d81
-/subprocess/service-behavior:
-  en: b567e801cc15900a
-  zh: a00bfeb94c34bdb2

package/references/official-docs/docs/subsystems/subprocess.md

@@ -1,321 +0,0 @@
-# Subprocess
-
-English | [中文](subprocess.zh.md)
-
-The subprocess seam is split across a Service Definition ([dsh-subprocess](../../packages/subprocess/subprocess), `ctx.subprocess`) and Service Provider ([dsh-subprocess-local](../../packages/subprocess/subprocess-local)); its Consumers are other capability seams and out-of-process backends: the [bash executor family](shell.md) uses collected batch output, LSP uses raw protocol pipes, the PTY backend uses the terminal primitive, and the ACP subagent backend uses piped ndjson plus inherited stderr. This seam owns the managed `DSH_*` environment namespace, the shared credential scrub (`scrubbedParentEnv`), and the `CollectedOutput` shape; [dsh-shell](../../packages/shell/shell) re-exports the vocabulary so bash consumers keep one import root.
-
-Source: [`packages/subprocess/subprocess/src/types.ts`](../../packages/subprocess/subprocess/src/types.ts) and [`packages/subprocess/subprocess/src/index.ts`](../../packages/subprocess/subprocess/src/index.ts)
-
-## Executable lookup
-
-One provider's spawn working directories, executable paths, ordinary processes, and terminal sessions inhabit the same path and process namespace as the mounted filesystem provider. `resolveExecutable(command, env?, signal?)` verifies absolute executable paths or resolves bare names through the provider's scrubbed `PATH` plus deliberate overrides.
-
-## Managed environment namespace and captured output
-
-`DSH_*` variables are Harness-owned child-process facts; implementations discard ambient `DSH_*` names before the caller's explicit `env` merges, so a current fact arrives only as a deliberate string entry, while an explicit `undefined` tombstone removes an ordinary ambient value. Each collected stream reports its truncation and spill-recovery state through `CollectedOutput`.
-
-```ts type-equiv
-/** One environment key inside the managed {@link DSH_ENV_PREFIX} namespace. */
-type DshEnvironmentKey = `${typeof DSH_ENV_PREFIX}${string}`
-```
-
-```ts type-equiv
-/** Trusted DeepSeek Harness variables for one child-process execution. */
-type DshEnvironment = Readonly<Record<DshEnvironmentKey, string>>
-```
-
-```ts type-equiv
-/** One captured stream: the (possibly truncated) text plus recovery info. */
-interface CollectedOutput {
-  /** Collected text — the TAIL of the stream when truncated. */
-  text: string
-  /** True when bytes were dropped from `text`. */
-  truncated: boolean
-  /** Path to a file holding the COMPLETE stream, when truncated and available. */
-  spillPath?: string
-}
-```
-
-## Node-shaped stdio dispositions
-
-Each stream's disposition is explicit, chosen per consumer: raw pipes for protocol framing (LSP JSON-RPC, ACP ndjson), inherit for pass-through diagnostics, and collect mode for bounded batch output — with the spill file optional, so a diagnostic tail (a language server's stderr) buffers without leaving files behind.
-
-```ts type-equiv
-/**
- * stdin disposition. `'ignore'` leaves fd 0 on `/dev/null`; `'pipe'` exposes
- * {@link SubprocessHandle.stdin} for the caller's ongoing protocol writes;
- * `{ data }` writes the bytes and closes (the batch shape).
- */
-type SubprocessStdinMode = 'ignore' | 'pipe' | { readonly data: string }
-```
-
-```ts type-equiv
-/**
- * Bounded in-memory collection for one output stream, with an optional
- * full-stream spill file. Omitting `spill` keeps only the in-memory tail —
- * the diagnostic-tail shape (a language server's stderr); including it makes
- * the complete stream recoverable up to its cap (the bash tool shape).
- */
-interface SubprocessCollect {
-  /** In-memory cap in bytes; overflow keeps the TAIL. */
-  maxBytes: number
-  /** Full-stream spill file; absent disables spilling entirely. */
-  spill?: {
-    /** Whole-stream byte cap; a larger stream discards its now-incomplete spill. */
-    maxBytes: number
-  }
-}
-```
-
-```ts type-equiv
-/**
- * stdout/stderr disposition. `'pipe'` exposes the raw `Readable` for the
- * caller's protocol decoding; `'inherit'` passes the parent's descriptor
- * through (child diagnostics land on the harness's own stream); a
- * {@link SubprocessCollect} object buffers boundedly with offset-based reads.
- */
-type SubprocessOutputMode = 'pipe' | 'inherit' | SubprocessCollect
-```
-
-```ts type-equiv
-/** Per-stream stdio dispositions, all explicit — this seam applies no defaults. */
-interface SubprocessStdio {
-  stdin: SubprocessStdinMode
-  stdout: SubprocessOutputMode
-  stderr: SubprocessOutputMode
-  /** Request a separate byte-mode duplex channel; omission creates none. */
-  control?: 'pipe'
-}
-```
-
-## The fully-explicit spawn spec
-
-The seam applies no defaults: every disposition, limit, and directory is explicit on the spec, so the caller's own config — not a hidden subprocess-service default — decides them. `argv` is never shell-interpreted.
-
-```ts type-equiv
-/**
- * A fully-specified spawn request. This seam applies no defaults: every
- * disposition, limit, and directory is explicit, so the caller's own config —
- * not a hidden subprocess-service default — decides them (the `dsh-shell`
- * request/spec split is the owning template).
- */
-interface SubprocessSpawnSpec {
-  /** Executable and arguments; `argv[0]` is the program. Never shell-interpreted here. */
-  argv: readonly string[]
-  /** Working directory for the child. */
-  cwd: string
-  /** Per-stream stdio dispositions. */
-  stdio: SubprocessStdio
-  /**
-   * Positive finite grace period in milliseconds, no greater than
-   * `MAX_TIMER_DELAY_MS`, available to the provider's termination procedure
-   * and used for draining still-open collected pipes after the process exits
-   * (an inherited descriptor held by a survivor cannot hold the outcome open
-   * indefinitely). Providers document whether range termination is staged or
-   * immediate.
-   */
-  graceMs: number
-  /**
-   * Abort signal — starts the terminate escalation on the managed range when
-   * it fires. The caller owns deadlines and cause classification; this seam
-   * only reacts to the abort.
-   */
-  signal?: AbortSignal | undefined
-  /**
-   * Explicit environment entries merged onto the implementation's scrubbed
-   * parent base (see `scrubbedParentEnv`), with no namespace validation. A
-   * string is a deliberate caller opt-in, so a forwarded credential-shaped
-   * entry or current `DSH_*` fact survives the scrub; `undefined` is a
-   * tombstone that removes an ordinary ambient entry from the child.
-   */
-  env?: NodeJS.ProcessEnv | undefined
-}
-```
-
-## Handles: streams, readers, and managed-range termination
-
-A spawn returns a live handle synchronously while target and managed-range identities remain provider-private. Collect-mode readers take whole-stream byte offsets and never consume, so independent readers cannot steal one another's deltas; piped streams belong to the caller. `terminate()` starts the provider's documented procedure, and `waitForExit()` observes the same provider-managed range; staged providers may use `graceMs`, while immediate providers do not delay. Consumers can build their own teardown ladders over those two operations (the ACP backend's stdin-EOF-first `disposeAcpChild` is the template).
-
-```ts type-equiv
-/**
- * A live subprocess and its provider-managed process range. Collected output
- * remains readable after exit; piped streams belong to the caller.
- *
- * Termination and {@link SubprocessHandle.waitForExit} use the same managed
- * range. Each provider documents the range it can observe and its signalling
- * and observation limits.
- */
-interface SubprocessHandle {
-  /** The child's stdin, present iff spawned with `stdin: 'pipe'`. */
-  readonly stdin: Writable | undefined
-  /** The child's raw stdout, present iff spawned with `stdout: 'pipe'`. */
-  readonly stdout: Readable | undefined
-  /** The child's raw stderr, present iff spawned with `stderr: 'pipe'`. */
-  readonly stderr: Readable | undefined
-  /** Separate caller-owned byte channel when requested; native startup failure may leave it absent. */
-  readonly control: Duplex | undefined
-  /** Offset-based readers for collect-mode streams (also readable after exit). */
-  readonly collected: SubprocessCollectedOutputs
-  /** Resolves with spawned-command exit facts; rejects for spawn or provider failures. */
-  readonly done: Promise<SubprocessOutcome>
-  /**
-   * Begin the provider's documented termination procedure on the managed range
-   * — the seam's only termination verb. Idempotent, a no-op once that range is
-   * gone, and also triggered by the spec's abort signal.
-   */
-  terminate(): void
-  /**
-   * Wait until the same managed range is empty — not just until the spawned
-   * command reports its outcome, so surviving work remains observable.
-   * @param signal - optional bound for the wait.
-   * @returns `true` when the managed range is empty, `false` when the signal aborted first.
-   * @throws when the selected provider can no longer observe its managed range.
-   */
-  waitForExit(signal?: AbortSignal): Promise<boolean>
-}
-```
-
-```ts type-equiv
-/**
- * Cursor-free incremental access to one collected output stream. Offsets are
- * whole-stream byte coordinates owned by the caller, so independent readers
- * cannot consume one another's output; `readFrom(0)` after settlement is the
- * batch result (`lossy` then means the in-memory tail lost its head — the
- * {@link CollectedOutput.truncated} fact).
- */
-interface SubprocessOutputReader {
-  /**
-   * Read everything captured since `fromByte`. When that offset has slid out
-   * of the in-memory tail window the read is `lossy` — it returns the whole
-   * retained tail and the gap is only recoverable from the spill file.
-   * @param fromByte - whole-stream offset to resume from (a prior read's `nextOffset`; 0 for the first read).
-   * @returns the delta text, the next offset, the `lossy` flag, and the spill path when one exists.
-   */
-  readFrom(fromByte: number): SubprocessOutputRead
-}
-```
-
-```ts type-equiv
-/** One incremental {@link SubprocessOutputReader.readFrom} read. */
-interface SubprocessOutputRead {
-  /** Stream text from the requested offset (the whole retained tail when lossy). */
-  text: string
-  /** Whole-stream offset to resume from on the next read. */
-  nextOffset: number
-  /** True when the requested offset slid out of the in-memory tail window. */
-  lossy: boolean
-  /** Path to the full-stream spill file, when one was created and remains intact. */
-  spillPath?: string
-}
-```
-
-```ts type-equiv
-/** Offset-based readers for the streams spawned in collect mode. */
-interface SubprocessCollectedOutputs {
-  /** Present iff stdout is a {@link SubprocessCollect}. */
-  readonly stdout?: SubprocessOutputReader
-  /** Present iff stderr is a {@link SubprocessCollect}. */
-  readonly stderr?: SubprocessOutputReader
-}
-```
-
-
-## Outcomes carry exit facts only
-
-`done` reports Node's close-event vocabulary and no cause classification — the service kills on abort but never decides why (the caller reads the deadline signal it owns, e.g. the bash executor's `timedOut`/`aborted` split). Collected output stays readable through `handle.collected` after settlement, so batch and streaming callers share one access path.
-
-```ts type-equiv
-/**
- * Exit facts of one closed process — Node's `close`-event vocabulary.
- * Deliberately carries NO timeout or cancellation classification (the caller
- * reads the signal it owns to classify causes) and NO output: collected
- * streams stay readable through {@link SubprocessHandle.collected} after
- * settlement, so batch and streaming callers share one access path.
- */
-interface SubprocessOutcome {
-  /** Exit code; null when the process died from a signal. */
-  exitCode: number | null
-  /** Terminating signal (e.g. 'SIGTERM'); null on normal exit. */
-  signal: NodeJS.Signals | null
-}
-```
-
-## Terminal-process primitive
-
-`spawnTerminal(spec)` is the non-pipe process primitive. The provider allocates the controlling terminal and owns UTF-8 text transport, foreground-process-group inspection and signalling, and one awaited TERM-to-KILL operation that reaches quiescence for every session member the provider can still observe; providers document substrate-specific observability limits. The PTY backend remains responsible for prompt detection, readiness inference, scrollback, sandbox policy, and persistent-session ownership; ordinary `spawn()` cannot reconstruct controlling-terminal semantics.
-
-The terminal spec fully specifies argv, cwd, environment overrides, terminal type, dimensions, cleanup grace, and optional allocation cancellation and shell activity observation. Its handle exposes `pid`, ordered output, `done`, `write`, `resize`, `inspectForeground`, `inspectActivity`, `signalForeground`, and awaited `terminate`; [`SubprocessTerminalSpawnSpec` and `SubprocessTerminalHandle`](../../packages/subprocess/subprocess/src/types.ts) define these fields and operations. `resize(cols, rows)` updates the live PTY dimensions and rejects after process exit.
-
-`inspectActivity()` returns `SubprocessTerminalActivity`: `state` is `idle`, `busy` or `unknown`, and `revision` changes with provider-observed activity or input. A terminal request opts into supported shell lifecycle observation with `shellActivity`; provider-specific support and conservative unknown cases are documented by [subprocess-local](../../packages/subprocess/subprocess-local/README.md#running-terminal-sessions).
-
-`terminalEnvironment(signal?)` returns `SubprocessTerminalEnvironment`: the execution environment platform (`posix` or `windows`) and optional `defaultShell`. These facts come from the provider rather than the Web server or browser. `resolveExecutable` verifies shell candidates; `SubprocessExecutableNotFoundError` identifies a missing executable, while provider and transport failures remain errors.
-
-## Service behavior
-
-The abstract [`SubprocessRuntime`](../../packages/subprocess/subprocess/src/index.ts) Service Definition specifies execution-world coordinates, executable lookup, ordinary `spawn`, and `spawnTerminal`. [`LocalSubprocessRuntime`](../../packages/subprocess/subprocess-local/src/index.ts) provides them with platform-selected managed ranges, per-disposition wiring, credential scrubbing, `node-pty`, platform process inspection, and terminate-and-join disposal. See [`dsh-subprocess`](../../packages/subprocess/subprocess/README.md) for the Service Definition contract and [`dsh-subprocess-local`](../../packages/subprocess/subprocess-local/README.md) for local mechanics.
-
-<!-- BEGIN GENERATED cordis-surface (gen-cordis-catalog.ts) — do not edit between markers -->
-
-<a id="cordis-surface"></a>
-
-## Cordis API
-
-Generated from source by `scripts/gen-cordis-catalog.ts` (verified fresh by `pnpm run verify-cordis-catalog` in doc-sync; regenerate with `pnpm run gen-cordis-catalog`) — the language sides differ only in locale-specific paired document paths. Signature blocks use a `ts cordis-catalog` fence and keep the original source JSDoc; dispatch modes are defined in the [primer](../cordis-primer.md#dispatch-modes), and the framework-inherited `ctx` API lives in [cordis-api/inherited.md](../cordis-api/inherited.md).
-
-<a id="ctxsubprocess--subprocessruntime-abstract-seam"></a>
-
-### `ctx.subprocess` — `SubprocessRuntime` (abstract seam)
-
-Abstract subprocess service. Subclass, implement spawn, and load the subclass as a plugin — it registers as `ctx.subprocess` (one implementation per context; loading a second throws, which is cordis' standard duplicate-service behavior).
-
-Implementations must honor these semantics:
-
-- Executable paths belong to one execution world shared with the mounted filesystem provider.
-- spawn returns a live handle synchronously. Target identity remains provider-private; `done` resolves with the spawned command's exit facts and may reject for spawn or provider failures.
-- Collect-mode readers are offset-based and non-consuming, so independent readers never consume one another's output; lossy reads report truncation and the spill file holding the complete stream when one exists. Piped streams are handed to the caller raw and never buffered here.
-- SubprocessHandle.terminate (and the spec's abort signal) starts the provider's documented procedure against its managed range. SubprocessHandle.waitForExit observes that same range so a consumer-owned teardown ladder can hold each tier on real quiescence; each provider documents its signalling and observability limits.
-- Disposal of the service terminates all still-running managed processes and awaits their exit.
-- spawnTerminal owns terminal allocation, text transport, foreground groups, signalling, and whole-session quiescence behind one awaited termination method; readiness and persistent-shell policy stay in the PTY consumer. Its output stream ends after queued terminal output when the top-level process exits.
-
-```ts cordis-catalog
-/**
- * Resolve one configured executable in this provider's execution world.
- * Absolute paths are verified; bare names use the provider's scrubbed PATH
- * plus explicit environment overrides. Relative paths containing separators
- * are rejected: the resolution base is undefined, so providers fail loud
- * instead of guessing.
- * @param command - absolute executable path or bare PATH name.
- * @param env - explicit environment entries used for lookup.
- * @param signal - aborts remote or local lookup.
- * @returns a canonical executable path.
- */
-abstract resolveExecutable( command: string, env?: Readonly<Record<string, string>>, signal?: AbortSignal, ): Promise<string>
-
-/**
- * Inspect shell-selection facts in the provider's execution environment.
- * @param signal - cancellation of remote environment inspection.
- * @returns platform and preferred shell; executable lookup and allocation remain separate operations.
- */
-abstract terminalEnvironment(signal?: AbortSignal): Promise<SubprocessTerminalEnvironment>
-
-/**
- * Start one managed child process from a fully-specified spec; this seam
- * applies no defaults.
- * @param spec - argv, directory, stdio dispositions, grace, cancellation, and environment.
- * @returns the live process handle (streams/readers, signalling, outcome promise).
- * @throws synchronously when pre-aborted or when argv, cwd, environment, or grace is invalid before handle creation.
- */
-abstract spawn(spec: SubprocessSpawnSpec): SubprocessHandle
-
-/**
- * Allocate a real terminal and start one owned process session. This is the
- * only non-pipe process primitive: implementations own terminal byte I/O,
- * foreground groups, signals, and whole-session quiescence.
- * @param spec - fully specified argv, cwd, environment, dimensions, grace, and allocation cancellation.
- * @returns the live terminal handle after allocation succeeds.
- */
-abstract spawnTerminal(spec: SubprocessTerminalSpawnSpec): Promise<SubprocessTerminalHandle>
-```
-
-Source: [`packages/subprocess/subprocess/src/index.ts`](../../packages/subprocess/subprocess/src/index.ts)
-<!-- END GENERATED cordis-surface -->