@exagone313/dsh-podman 0.2.0-rc.3 → 0.2.0

package/dist/spill-store.test.js

@@ -3,14 +3,13 @@
 // SPDX-License-Identifier: MIT
 import test from "node:test";
 import assert from "node:assert/strict";
-import { createSpillStore } from "./spill-store.js";
+import { createSpillStore, sessionSegment } from "./spill-store.js";
 import { guestFileRecorder } from "./test-support.js";
 const SESSION_ID = "2c573001-4171-4900-904b-12a5cc02737a";
+const SEGMENT = sessionSegment(SESSION_ID);
 function fakeCtx(sessions) {
     return {
-        get: (name) => name === "sessions"
-            ? { get: (id) => sessions[id] }
-            : undefined,
+        get: (name) => name === "sessions" ? { get: (id) => sessions[id] } : undefined,
     };
 }
 function withSession() {
@@ -22,13 +21,18 @@ test("saveText writes a tool-result spill inside the session container", async (
     const content = "x".repeat(60000);
     const ref = await store.saveText({
         owner: { sessionId: SESSION_ID },
-        source: { kind: "tool", toolName: "web_fetch", callId: "c1", label: "result" },
+        source: {
+            kind: "tool",
+            toolName: "web_fetch",
+            callId: "c1",
+            label: "result",
+        },
         suggestedName: "web_fetch.txt",
         content,
     });
-    assert.equal(mkdirs[0], `/tmp/dsh-podman/spill/${SESSION_ID}`);
+    assert.equal(mkdirs[0], `/tmp/dsh-podman/spill/${SEGMENT}`);
     assert.equal(writes.length, 1);
-    assert.match(writes[0].path, new RegExp(`^/tmp/dsh-podman/spill/${SESSION_ID}/[0-9a-f]{32}-web_fetch\\.txt$`));
+    assert.match(writes[0].path, new RegExp(`^/tmp/dsh-podman/spill/${SEGMENT}/[0-9a-f]{32}-web_fetch\\.txt$`));
     assert.equal(ref.locator, writes[0].path);
     assert.equal(ref.bytes, content.length);
     assert.equal(writes[0].content, content, "the full text is persisted verbatim");
@@ -43,10 +47,29 @@ test("saveText never lets the suggested name escape the spill directory", async
         suggestedName: "../../etc/passwd",
         content: "x",
     });
-    assert.ok(ref.locator.startsWith(`/tmp/dsh-podman/spill/${SESSION_ID}/`));
+    assert.ok(ref.locator.startsWith(`/tmp/dsh-podman/spill/${SEGMENT}/`));
     assert.ok(!ref.locator.includes(".."));
     assert.equal(writes.length, 1);
 });
+test("sessionSegment neutralizes path-shaped session ids", () => {
+    // A session id is not necessarily a UUID, so it must never survive as a path
+    // segment that can traverse or collide.
+    for (const id of ["..", ".", "../../etc", "a/b", "session-1", "sess..ion", ""]) {
+        const segment = sessionSegment(id);
+        assert.notEqual(segment, "");
+        assert.notEqual(segment, ".");
+        assert.notEqual(segment, "..");
+        assert.doesNotMatch(segment, /[^A-Za-z0-9_-]/);
+        assert.ok(!segment.includes(".."), `${JSON.stringify(id)} -> ${segment}`);
+    }
+    // Distinct ids never share a directory, even when their readable prefixes do.
+    assert.notEqual(sessionSegment("session-1"), sessionSegment("session_1"));
+    // The readable prefix is kept for debugging.
+    assert.match(sessionSegment("session-42"), /^session-42-/);
+    // A UUID-shaped id stays recognizable.
+    assert.match(SEGMENT, /^2c573001-4171-4900-904b-[0-9a-f]+$/);
+    assert.equal(sessionSegment(SESSION_ID), SEGMENT);
+});
 test("saveText rejects when the session has no working directory", async () => {
     const { resolver } = guestFileRecorder();
     const store = createSpillStore(fakeCtx({}), resolver);

package/dist/subprocess.d.ts

@@ -1,6 +1,10 @@
 import { type WorkspaceResolver } from "./workspace-binding.js";
 export interface SubprocessProvider {
     resolveExecutable(command: string): Promise<string>;
+    terminalEnvironment(signal?: AbortSignal): Promise<{
+        platform: "posix";
+        defaultShell: string;
+    }>;
     spawn(spec: any): any;
     spawnTerminal(spec: any): Promise<any>;
     dispose(): void;

package/dist/subprocess.js

@@ -1,11 +1,12 @@
 // SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
 //
 // SPDX-License-Identifier: MIT
-import { discardUnneededSpill, outputReader, spillTargetFor, splitEnv } from "./output-reader.js";
+import { discardUnneededSpill, outputReader, spillTargetFor, splitEnv, } from "./output-reader.js";
+import { openGuestTerminal } from "./guest-terminal.js";
 import { globCwd, remoteArgv, unaryGuest } from "./guest-rpc.js";
 import { metadata } from "./workspace-binding.js";
-import { randomUUID } from "node:crypto";
 import { PassThrough } from "node:stream";
+import { SubprocessExecutableNotFoundError } from "@deepseek-ai/dsh-subprocess";
 export function createSubprocessProvider(resolver) {
     // Live termination handles, so service disposal can stop every process this
     // provider started (the harness's disposal contract).
@@ -17,12 +18,24 @@ export function createSubprocessProvider(resolver) {
         },
         // The harness's resolveExecutable carries no cwd, and this provider's
         // execution world is per-workspace (each workspace is its own container),
-        // so there is no context in which an executable can be verified or looked
-        // up. Report every request as unresolvable instead of returning an
-        // unverified path.
+        // so a bare command name cannot be looked up here. An absolute path is
+        // returned unchanged: the guest resolves and spawns it inside the target
+        // container, which is the only place it can be checked. A bare name is
+        // reported in the harness's "not found" form, so shell discovery skips a
+        // candidate the images do not carry instead of failing the whole list.
         resolveExecutable: async (command) => {
-            throw new Error(`cannot resolve executable ${JSON.stringify(command)}: no workspace context is available`);
+            if (typeof command === "string" && command.startsWith("/")) {
+                return command;
+            }
+            throw new SubprocessExecutableNotFoundError(`cannot resolve executable ${JSON.stringify(command)}: no workspace context is available`);
         },
+        // Shell selection happens before a workspace is chosen, so the provider
+        // reports the family every container it starts belongs to. `/bin/sh` is the
+        // portable default; a configured shell overrides it.
+        terminalEnvironment: async (_signal) => ({
+            platform: "posix",
+            defaultShell: "/bin/sh",
+        }),
         spawn: (spec) => {
             // A pre-aborted spawn is rejected synchronously with a stable Error,
             // mirroring the local backend, rather than starting a process that would
@@ -40,8 +53,9 @@ export function createSubprocessProvider(resolver) {
             if (!Array.isArray(spec.argv) ||
                 spec.argv.length === 0 ||
                 typeof spec.argv[0] !== "string" ||
-                spec.argv[0] === "")
+                spec.argv[0] === "") {
                 throw new Error("argv must contain a program");
+            }
             const stdoutSpill = spillTargetFor(spec.stdio?.stdout, "stdout");
             const stderrSpill = spillTargetFor(spec.stdio?.stderr, "stderr");
             const stdoutReader = outputReader(spec.stdio?.stdout, stdoutSpill.spec);
@@ -80,6 +94,36 @@ export function createSubprocessProvider(resolver) {
                     killTimer.unref?.();
                 }
             };
+            let settled = false;
+            // A piped consumer that falls behind applies backpressure: the guest
+            // stream is paused until every outstanding drain (or close) has fired, so
+            // a fast producer cannot grow a PassThrough without bound.
+            let pendingDrains = 0;
+            const applyBackpressure = (stream, target) => {
+                pendingDrains++;
+                stream.pause?.();
+                let released = false;
+                const release = () => {
+                    if (released)
+                        return;
+                    released = true;
+                    target.removeListener("drain", release);
+                    target.removeListener("close", release);
+                    pendingDrains--;
+                    if (pendingDrains === 0)
+                        stream.resume?.();
+                };
+                target.once("drain", release);
+                // A destroyed target never drains; its close must release the pause or
+                // the exit message would stay stuck behind it.
+                target.once("close", release);
+            };
+            const writeChunk = (stream, target, data) => {
+                if (target === undefined)
+                    return;
+                if (!target.write(data))
+                    applyBackpressure(stream, target);
+            };
             // A ripgrep discovery listing runs from its search root, so a pattern
             // containing "/" anchors to the path the harness passed; the workspace
             // binding still resolves from the caller's cwd.
@@ -87,13 +131,43 @@ export function createSubprocessProvider(resolver) {
             const done = resolver.resolve(spec.cwd).then((binding) => new Promise((resolveDone, reject) => {
                 processBinding = binding;
                 const stream = binding.guest.exec(metadata(binding.token));
+                // finish settles the handle exactly once and tears it down however
+                // the process ends: an exit message, a stream error, or a stream
+                // that ends without one. The output pipes and spill files are
+                // resolved on every path, so a failed exec leaves no half-open
+                // handle, no hung reader, and no orphaned spill.
+                const finish = (error, exit) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    exited = true;
+                    if (killTimer !== undefined) {
+                        clearTimeout(killTimer);
+                        killTimer = undefined;
+                    }
+                    // A pause applied for backpressure must not outlive the process,
+                    // or the exit/error message could stay stuck behind it.
+                    if (pendingDrains > 0) {
+                        pendingDrains = 0;
+                        stream.resume?.();
+                    }
+                    state.stdout?.end();
+                    state.stderr?.end();
+                    discardUnneededSpill(binding, stdoutReader);
+                    discardUnneededSpill(binding, stderrReader);
+                    if (error === undefined)
+                        resolveDone(exit);
+                    else
+                        reject(error);
+                };
                 stream.on("data", (output) => {
                     if (output.stdoutChunk) {
                         const data = Buffer.from(output.stdoutChunk);
                         stdoutReader?.append(data);
-                        state.stdout?.write(data);
-                        if (spec.stdio?.stdout === "inherit")
+                        writeChunk(stream, state.stdout, data);
+                        if (spec.stdio?.stdout === "inherit") {
                             process.stdout.write(data);
+                        }
                     }
                     if (output.processId) {
                         state.pid = Number(output.processId);
@@ -103,27 +177,35 @@ export function createSubprocessProvider(resolver) {
                     if (output.stderrChunk) {
                         const data = Buffer.from(output.stderrChunk);
                         stderrReader?.append(data);
-                        state.stderr?.write(data);
-                        if (spec.stdio?.stderr === "inherit")
+                        writeChunk(stream, state.stderr, data);
+                        if (spec.stdio?.stderr === "inherit") {
                             process.stderr.write(data);
+                        }
                     }
                     if (output.exit) {
-                        exited = true;
-                        if (killTimer !== undefined)
-                            clearTimeout(killTimer);
                         stdoutReader?.setSpillValid(Boolean(output.exit.stdoutSpillValid));
                         stderrReader?.setSpillValid(Boolean(output.exit.stderrSpillValid));
-                        state.stdout?.end();
-                        state.stderr?.end();
-                        discardUnneededSpill(binding, stdoutReader);
-                        discardUnneededSpill(binding, stderrReader);
-                        resolveDone({
+                        finish(undefined, {
                             exitCode: output.exit.exitCode,
                             signal: output.exit.signaled ? output.exit.signal : null,
                         });
                     }
                 });
-                stream.on("error", reject);
+                stream.on("error", (error) => {
+                    // The guest connection failed: stop the process if it is still
+                    // reachable, then release the caller instead of leaving it
+                    // pending on a stream that will never carry an exit message.
+                    terminate();
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                });
+                stream.on("end", () => {
+                    // A stream that ends without an exit message (guest restart,
+                    // dropped socket) must not leave the caller pending forever.
+                    if (settled)
+                        return;
+                    terminate();
+                    finish(new Error("exec stream ended before the process exited"));
+                });
                 const env = splitEnv(spec.env);
                 stream.write({
                     start: {
@@ -161,6 +243,9 @@ export function createSubprocessProvider(resolver) {
             void done.finally(() => live.delete(terminate)).catch(() => { });
             return {
                 ...state,
+                // The harness's SubprocessHandle declares a control channel; this
+                // provider runs every process over gRPC, so none exists.
+                control: undefined,
                 collected: {
                     ...(stdoutReader === undefined ? {} : { stdout: stdoutReader }),
                     ...(stderrReader === undefined ? {} : { stderr: stderrReader }),
@@ -195,162 +280,50 @@ export function createSubprocessProvider(resolver) {
             if (!Array.isArray(spec.argv) ||
                 spec.argv.length === 0 ||
                 typeof spec.argv[0] !== "string" ||
-                spec.argv[0] === "")
+                spec.argv[0] === "") {
                 throw new Error("argv must contain a program");
+            }
             spec.signal?.throwIfAborted();
             const binding = await resolver.resolveForPath(spec.cwd, spec.cwd);
-            const call = binding.guest.terminal(metadata(binding.token));
-            const output = new PassThrough();
-            let exited = false;
-            let terminated = false;
-            let resolveExit;
-            let rejectExit;
-            const done = new Promise((resolveDone, rejectDone) => {
-                resolveExit = resolveDone;
-                rejectExit = rejectDone;
-            });
-            // A caller that never receives the handle (startup failure) must not
-            // leave `done` as an unhandled rejection.
-            done.catch(() => { });
-            let resolveStarted;
-            let rejectStarted;
-            const started = new Promise((resolvePid, rejectPid) => {
-                resolveStarted = resolvePid;
-                rejectStarted = rejectPid;
+            const terminal = openGuestTerminal(binding, {
+                argv: spec.argv,
+                cwd: spec.cwd,
+                env: spec.env,
+                cols: spec.cols,
+                rows: spec.rows,
+                terminalType: spec.terminalType,
             });
-            const pending = new Map();
-            const failPending = (error) => {
-                for (const waiter of pending.values())
-                    waiter.reject(error);
-                pending.clear();
-            };
-            call.on("data", (message) => {
-                if (message.started) {
-                    resolveStarted(Number(message.started.pid));
-                    return;
-                }
-                if (message.stdoutChunk) {
-                    output.write(Buffer.from(message.stdoutChunk));
-                    return;
-                }
-                if (message.exit) {
-                    exited = true;
-                    output.end();
-                    resolveExit({
-                        exitCode: message.exit.exitCode,
-                        signal: message.exit.signaled ? message.exit.signal : null,
-                    });
-                    return;
-                }
-                if (message.foreground) {
-                    const waiter = pending.get(message.foreground.requestId);
-                    if (waiter !== undefined) {
-                        pending.delete(message.foreground.requestId);
-                        waiter.resolve(message.foreground);
-                    }
-                    return;
-                }
-                if (message.signalled) {
-                    const waiter = pending.get(message.signalled.requestId);
-                    if (waiter !== undefined) {
-                        pending.delete(message.signalled.requestId);
-                        waiter.resolve(message.signalled);
-                    }
-                }
-            });
-            call.on("error", (error) => {
-                rejectStarted(error);
-                if (!exited) {
-                    exited = true;
+            const output = new PassThrough();
+            terminal.onOutput((chunk) => output.write(chunk));
+            // Startup failure rejects here, before the caller receives a handle.
+            const pid = await terminal.started;
+            const done = terminal.done;
+            // The handle's output ends however the stream settles, so a consumer
+            // reading it is released on exit exactly as it was on a clean close.
+            const endOutput = () => {
+                if (!output.writableEnded)
                     output.end();
-                    rejectExit(error);
-                }
-                failPending(error);
-            });
-            call.on("end", () => {
-                if (exited)
-                    return;
-                const error = new Error("terminal stream ended before the process exited");
-                rejectStarted(error);
-                exited = true;
-                output.end();
-                rejectExit(error);
-                failPending(error);
-            });
-            call.write({
-                start: {
-                    argv: remoteArgv(spec.argv),
-                    cwd: spec.cwd,
-                    env: spec.env ?? {},
-                    rows: spec.rows,
-                    cols: spec.cols,
-                },
-            });
-            const pid = await started;
-            const request = (message) => {
-                const requestId = randomUUID();
-                return new Promise((resolveWaiter, rejectWaiter) => {
-                    pending.set(requestId, { resolve: resolveWaiter, reject: rejectWaiter });
-                    try {
-                        call.write(message(requestId));
-                    }
-                    catch (error) {
-                        pending.delete(requestId);
-                        rejectWaiter(error);
-                    }
-                });
             };
+            void done.then(endOutput, endOutput).catch(() => { });
             const handle = {
                 pid,
                 output,
                 done,
                 write: async (data) => {
-                    if (exited)
-                        throw new Error("terminal has exited");
-                    call.write({ stdinChunk: Buffer.from(data) });
-                },
-                inspectForeground: async () => {
-                    if (exited)
-                        return undefined;
-                    const response = await request((requestId) => ({
-                        inspectRequestId: requestId,
-                    }));
-                    return response.found
-                        ? {
-                            processGroupId: response.processGroupId,
-                            inputWaiting: response.inputWaiting,
-                        }
-                        : undefined;
+                    terminal.write(data);
                 },
-                signalForeground: async (signal) => {
-                    if (exited)
-                        throw new Error("terminal has exited");
-                    const response = await request((requestId) => ({
-                        signal: { signal, requestId },
-                    }));
-                    if (!response.found)
-                        throw new Error(`no foreground process group to signal ${signal}`);
-                    return response.processGroupId;
+                resize: async (cols, rows) => {
+                    terminal.resize(cols, rows);
                 },
+                inspectActivity: async () => ({
+                    state: "unknown",
+                    revision: terminal.activityRevision(),
+                }),
+                inspectForeground: async () => terminal.inspectForeground(),
+                signalForeground: async (signal) => terminal.signalForeground(signal),
                 terminate: async () => {
-                    if (terminated)
-                        return;
-                    terminated = true;
-                    try {
-                        call.write({ close: true });
-                        call.end();
-                    }
-                    catch {
-                        // A finished call cannot be closed again; nothing to do.
-                    }
-                    try {
-                        await done;
-                    }
-                    catch {
-                        // Termination is idempotent and never rejects.
-                    }
-                    if (!output.writableEnded)
-                        output.end();
+                    await terminal.terminate();
+                    endOutput();
                 },
             };
             const onAbort = () => {
@@ -362,6 +335,19 @@ export function createSubprocessProvider(resolver) {
                 else
                     spec.signal.addEventListener("abort", onAbort, { once: true });
             }
+            // Register the terminal with the provider's live handles, so disposing
+            // the service stops a terminal the caller never closed. Termination is
+            // idempotent and never rejects.
+            const stop = () => {
+                try {
+                    void handle.terminate();
+                }
+                catch {
+                    // Terminal teardown is best-effort.
+                }
+            };
+            live.add(stop);
+            void done.finally(() => live.delete(stop)).catch(() => { });
             return handle;
         },
     };

package/dist/subprocess.test.js

@@ -3,8 +3,9 @@
 // SPDX-License-Identifier: MIT
 import test from "node:test";
 import assert from "node:assert/strict";
-import { FakeTerminalCall, fakeTerminalResolver, spawnGuest, spawnSpec } from "./test-support.js";
-import { createSubprocessProvider, globCwd, outputReader, remoteArgv } from "./index.js";
+import { FakeTerminalCall, fakeTerminalResolver, spawnGuest, spawnSpec, } from "./test-support.js";
+import { createSubprocessProvider, globCwd, outputReader, remoteArgv, } from "./index.js";
+import { SubprocessExecutableNotFoundError } from "@deepseek-ai/dsh-subprocess";
 test("globCwd runs a discovery listing from its absolute search root", () => {
     assert.equal(globCwd(["rg", "--files", "--glob=sub/b.txt", "--", "/tmp/globtest"], "/projects/team"), "/tmp/globtest");
     assert.equal(globCwd(["rg", "--files", "--glob=a", "--", "sub"], "/projects/team"), undefined, "a relative root keeps the caller's cwd");
@@ -102,6 +103,26 @@ test("outputReader drops bytes beyond the retention window", () => {
     assert.equal(read.nextOffset, 10);
     assert.equal(read.lossy, true);
 });
+test("outputReader with a zero cap retains nothing", () => {
+    const spill = { path: "/tmp/dsh-podman/x.stdout", maxBytes: 64 };
+    const reader = outputReader({ maxBytes: 0 }, spill);
+    reader.append(Buffer.from("abcdef"));
+    // `subarray(-0)` is the whole buffer, so a zero cap must be special-cased.
+    assert.equal(reader.readFrom(0).text, "");
+    assert.equal(reader.readFrom(0).lossy, true);
+    assert.equal(reader.spillNeeded, true);
+    assert.equal(reader.readFrom(0).spillPath, spill.path);
+});
+test("outputReader keeps the exact tail across many small chunks", () => {
+    const reader = outputReader({ maxBytes: 4 });
+    for (const character of "0123456789") {
+        reader.append(Buffer.from(character));
+    }
+    const read = reader.readFrom(0);
+    assert.equal(read.text, "6789");
+    assert.equal(read.nextOffset, 10);
+    assert.equal(read.lossy, true);
+});
 test("outputReader honors in-window offsets", () => {
     const reader = outputReader({ maxBytes: 5 });
     reader.append(Buffer.from("abcdefghij"));
@@ -112,12 +133,22 @@ test("outputReader honors in-window offsets", () => {
     assert.equal(pastEnd.text, "");
     assert.equal(pastEnd.lossy, false);
 });
-test("resolveExecutable rejects every request without a workspace context", async () => {
+test("resolveExecutable returns absolute paths and reports bare names as not found", async () => {
     const provider = createSubprocessProvider({});
-    await assert.rejects(() => provider.resolveExecutable(""));
-    await assert.rejects(() => provider.resolveExecutable("bin/tool"));
-    await assert.rejects(() => provider.resolveExecutable("ls"));
-    await assert.rejects(() => provider.resolveExecutable("/usr/bin/ls"));
+    assert.equal(await provider.resolveExecutable("/usr/bin/ls"), "/usr/bin/ls");
+    assert.equal(await provider.resolveExecutable("/bin/sh"), "/bin/sh");
+    // The harness treats only this class as "not installed", so shell discovery
+    // skips a candidate the images do not carry instead of failing.
+    for (const command of ["", "bin/tool", "ls", "zsh"]) {
+        await assert.rejects(() => provider.resolveExecutable(command), SubprocessExecutableNotFoundError);
+    }
+});
+test("terminalEnvironment reports the container's shell family", async () => {
+    const provider = createSubprocessProvider({});
+    assert.deepEqual(await provider.terminalEnvironment(), {
+        platform: "posix",
+        defaultShell: "/bin/sh",
+    });
 });
 test("spawnTerminal drives the guest terminal stream", async () => {
     const fake = new FakeTerminalCall();
@@ -127,15 +158,22 @@ test("spawnTerminal drives the guest terminal stream", async () => {
         cwd: "/projects/team",
         rows: 24,
         cols: 80,
+        terminalType: "xterm-256color",
         graceMs: 1000,
     });
     assert.equal(handle.pid, 42);
+    assert.equal(fake.start.env.TERM, "xterm-256color");
     const chunks = [];
     handle.output.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
     const outputEnded = new Promise((resolve) => handle.output.on("end", resolve));
     fake.emitStdout(Buffer.from("hello"));
     await handle.write("ls\n");
     assert.deepEqual(fake.stdinChunks.map((chunk) => chunk.toString("utf8")), ["ls\n"]);
+    await handle.resize(100, 40);
+    assert.deepEqual(fake.resizes, [{ rows: 40, cols: 100 }]);
+    const activity = await handle.inspectActivity();
+    assert.equal(activity.state, "unknown");
+    assert.ok(activity.revision > 0, "observed activity must advance the revision");
     assert.deepEqual(await handle.inspectForeground(), {
         processGroupId: 7,
         inputWaiting: true,
@@ -149,7 +187,12 @@ test("spawnTerminal drives the guest terminal stream", async () => {
 });
 test("spawnTerminal rejects an empty argv", async () => {
     const provider = createSubprocessProvider(fakeTerminalResolver(new FakeTerminalCall()));
-    await assert.rejects(() => provider.spawnTerminal({ argv: [], cwd: "/projects/team", rows: 24, cols: 80 }), /argv must contain a program/);
+    await assert.rejects(() => provider.spawnTerminal({
+        argv: [],
+        cwd: "/projects/team",
+        rows: 24,
+        cols: 80,
+    }), /argv must contain a program/);
 });
 test("subprocess provider terminates live processes on dispose", async () => {
     const { signals, resolver } = spawnGuest({ emitExit: false });
@@ -232,3 +275,70 @@ test("subprocess provider keeps a spill that holds dropped output", async () =>
     assert.equal(read.lossy, true);
     assert.equal(read.spillPath, fake.starts[0].start.spillStdout.path);
 });
+test("subprocess provider tears down a failed exec stream", async () => {
+    const fake = spawnGuest({ emitExit: false });
+    const provider = createSubprocessProvider(fake.resolver);
+    const handle = provider.spawn(spawnSpec({
+        stdio: {
+            stdin: "ignore",
+            stdout: "pipe",
+            stderr: { maxBytes: 4, spill: { maxBytes: 64 } },
+        },
+    }));
+    await new Promise((resolve) => setImmediate(resolve));
+    const failed = assert.rejects(handle.done, /guest vanished/);
+    // A paused PassThrough only emits "end" once a consumer reads it to EOF.
+    handle.stdout.resume();
+    const outputEnded = new Promise((resolve) => handle.stdout.on("end", () => resolve()));
+    fake.streams[0].emit("error", new Error("guest vanished"));
+    await outputEnded;
+    await failed;
+    assert.ok(fake.signals.some((signal) => signal.signal === "SIGTERM"), "the process is asked to stop when its stream fails");
+    const spill = fake.starts[0].start.spillStderr.path;
+    assert.ok(fake.deletes.some((request) => request.path === spill), "the spill is deleted on the failure path");
+});
+test("subprocess provider rejects a stream that ends without an exit", async () => {
+    const fake = spawnGuest({ emitExit: false });
+    const provider = createSubprocessProvider(fake.resolver);
+    const handle = provider.spawn(spawnSpec());
+    await new Promise((resolve) => setImmediate(resolve));
+    const failed = assert.rejects(handle.done, /ended before the process exited/);
+    fake.streams[0].emit("end");
+    await failed;
+    assert.ok(fake.signals.some((signal) => signal.signal === "SIGTERM"), "a lost stream still asks the process to stop");
+});
+test("subprocess provider pauses a piped stream while the consumer is behind", async () => {
+    const chunk = "x".repeat(64 * 1024);
+    const fake = spawnGuest({ emitExit: false, stdout: chunk });
+    const provider = createSubprocessProvider(fake.resolver);
+    const handle = provider.spawn(spawnSpec({ stdio: { stdin: "ignore", stdout: "pipe", stderr: "pipe" } }));
+    await new Promise((resolve) => setImmediate(resolve));
+    const stream = fake.streams[0];
+    assert.ok(stream.paused > 0, "a full PassThrough pauses the guest stream");
+    const chunks = [];
+    await new Promise((resolve) => handle.stdout.on("data", (data) => {
+        chunks.push(Buffer.from(data));
+        if (Buffer.concat(chunks).length >= chunk.length)
+            resolve();
+    }));
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.ok(stream.resumed > 0, "draining the consumer resumes the stream");
+    const exited = handle.done;
+    stream.emitData({ exit: { exitCode: 0, signaled: false } });
+    assert.deepEqual(await exited, { exitCode: 0, signal: null });
+});
+test("subprocess provider disposes a live terminal", async () => {
+    const fake = new FakeTerminalCall();
+    const provider = createSubprocessProvider(fakeTerminalResolver(fake));
+    const handle = await provider.spawnTerminal({
+        argv: ["bash"],
+        cwd: "/projects/team",
+        rows: 24,
+        cols: 80,
+        graceMs: 1000,
+    });
+    assert.equal(handle.pid, 42);
+    provider.dispose();
+    assert.equal(fake.closed, true, "disposal closes the terminal");
+    assert.equal(fake.ended, true, "disposal ends the terminal stream");
+});

package/dist/terminal-preference.test.d.ts

@@ -0,0 +1 @@
+export {};