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

package/dist/guest-rpc.js

@@ -1,7 +1,10 @@
 // SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
 //
 // SPDX-License-Identifier: MIT
-import { metadata, workspaceSlug } from "./workspace-binding.js";
+import { metadata, workspaceSlug, } from "./workspace-binding.js";
+import { grpc } from "./grpc/runtime-client.js";
+import { discardUnneededSpill, outputReader, SPILL_ROOT, } from "./output-reader.js";
+import { randomUUID } from "node:crypto";
 import { isAbsolute, resolve as resolvePath } from "node:path";
 // Resolve a container-side path against the session working directory.
 // Absolute paths pass through unchanged. The session cwd and the container's
@@ -10,7 +13,9 @@ import { isAbsolute, resolve as resolvePath } from "node:path";
 function resolveAgainstSession(path, sessionCwd) {
     if (isAbsolute(path))
         return path;
-    const base = typeof sessionCwd === "string" && sessionCwd !== "" ? sessionCwd : undefined;
+    const base = typeof sessionCwd === "string" && sessionCwd !== ""
+        ? sessionCwd
+        : undefined;
     if (base === undefined) {
         throw new Error("relative paths need a session working directory; pass an absolute path");
     }
@@ -110,6 +115,26 @@ function onAbortCancel(call, signal) {
     signal.addEventListener("abort", cancel, { once: true });
     return () => signal.removeEventListener("abort", cancel);
 }
+// isUnauthenticated reports whether a guest call failed because the agent
+// rejected the caller's credential.
+function isUnauthenticated(error) {
+    return error?.code === grpc.status.UNAUTHENTICATED;
+}
+// withGuestAuth runs a guest call and, when the agent rejects the credential,
+// refreshes the binding once and retries. A rejection happens in the agent's
+// auth interceptor, before the handler runs, so the retry cannot duplicate a
+// side effect; a second rejection propagates.
+export async function withGuestAuth(binding, run) {
+    try {
+        return await run(binding.guest, binding.token);
+    }
+    catch (error) {
+        if (!isUnauthenticated(error) || binding.refresh === undefined)
+            throw error;
+        const refreshed = await binding.refresh();
+        return await run(refreshed.guest, refreshed.token);
+    }
+}
 // Stream raw bytes from the guest's ReadFile. A zero/absent length reads to
 // EOF. Cancelling the signal cancels the call and reports FS_ABORTED.
 export async function* guestChunks(target, range, signal) {
@@ -121,20 +146,48 @@ export async function* guestChunks(target, range, signal) {
     if (range?.length !== undefined && range.length > 0) {
         request.length = range.length;
     }
-    const call = target.binding.guest.readFile(request, metadata(target.binding.token));
-    const detach = onAbortCancel(call, signal);
-    try {
-        for await (const chunk of call) {
-            yield Buffer.from(chunk.data);
+    // The read is retried once with a refreshed binding when the agent rejects
+    // the credential, but only before any byte was emitted, so a retry can never
+    // duplicate output.
+    let binding = target.binding;
+    for (let attempt = 0;; attempt++) {
+        const call = binding.guest.readFile(request, metadata(binding.token));
+        const detach = onAbortCancel(call, signal);
+        let emitted = false;
+        let completed = false;
+        try {
+            for await (const chunk of call) {
+                emitted = true;
+                yield Buffer.from(chunk.data);
+            }
+            completed = true;
+            return;
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw fsError("FS_ABORTED", "read aborted");
+            if (attempt === 0 &&
+                !emitted &&
+                isUnauthenticated(error) &&
+                binding.refresh !== undefined) {
+                binding = await binding.refresh();
+                continue;
+            }
+            throw error;
+        }
+        finally {
+            detach();
+            if (!completed) {
+                // A consumer that stopped early (a bounded line read) or an error path
+                // must not leave the guest reading a file nobody consumes.
+                try {
+                    call.cancel?.();
+                }
+                catch {
+                    // The call already finished.
+                }
+            }
         }
-    }
-    catch (error) {
-        if (signal?.aborted)
-            throw fsError("FS_ABORTED", "read aborted");
-        throw error;
-    }
-    finally {
-        detach();
     }
 }
 // Stream the guest file as decoded UTF-8 text, rejecting binary content (a NUL
@@ -191,12 +244,14 @@ export function guestVersion(result) {
 }
 export async function writeGuestFile(binding, path, content, opts, signal) {
     throwIfAborted(signal, "write");
-    return new Promise((resolveDone, reject) => {
+    return withGuestAuth(binding, (guest, token) => new Promise((resolveDone, reject) => {
         let detach = () => { };
-        const call = binding.guest.writeFile(metadata(binding.token), {}, (error, result) => {
+        const call = guest.writeFile(metadata(token), {}, (error, result) => {
             detach();
             error
-                ? reject(signal?.aborted ? fsError("FS_ABORTED", "write aborted") : error)
+                ? reject(signal?.aborted
+                    ? fsError("FS_ABORTED", "write aborted")
+                    : error)
                 : resolveDone(Number(result?.bytesWritten ?? 0));
         });
         detach = onAbortCancel(call, signal);
@@ -205,78 +260,195 @@ export async function writeGuestFile(binding, path, content, opts, signal) {
         });
         call.write({ dataChunk: Buffer.from(content) });
         call.end();
-    });
+    }));
 }
 export async function readGuestFile(binding, path) {
-    const chunks = [];
-    await new Promise((resolveDone, reject) => {
-        const call = binding.guest.readFile({ path }, metadata(binding.token));
+    return withGuestAuth(binding, (guest, token) => new Promise((resolveDone, reject) => {
+        const chunks = [];
+        const call = guest.readFile({ path }, metadata(token));
         call.on("data", (chunk) => chunks.push(Buffer.from(chunk.data)));
         call.on("error", reject);
-        call.on("end", resolveDone);
-    });
-    return Buffer.concat(chunks).toString("utf8");
+        call.on("end", () => resolveDone(Buffer.concat(chunks).toString("utf8")));
+    }));
 }
 const READ_LIMIT = 2000;
-export async function runExec(binding, argv, cwd, env, timeoutMs, identity) {
-    const stdout = [];
-    const stderr = [];
-    return new Promise((resolveDone, reject) => {
-        const stream = binding.guest.exec(metadata(binding.token));
+// In-memory retention per stream for one command. The full stream is also
+// written to a bounded guest spill file, so the plugin never buffers an
+// unbounded command output and the caller can read the rest back with
+// container_read.
+const EXEC_RETAIN_BYTES = 1 << 20;
+const EXEC_SPILL_BYTES = 8 << 20;
+// The grace a cancelled command is given between SIGTERM and SIGKILL, matching
+// the harness's own termination grace.
+const EXEC_KILL_GRACE_MS = 5000;
+export async function runExec(binding, argv, cwd, env, timeoutMs, identity, options = {}) {
+    const signal = options.signal;
+    throwIfAborted(signal, "exec");
+    const maxBytes = options.maxBytes ?? EXEC_RETAIN_BYTES;
+    const spillBytes = options.spillBytes ?? EXEC_SPILL_BYTES;
+    const configuredGrace = Number(options.killGraceMs);
+    const killGraceMs = Number.isFinite(configuredGrace) && configuredGrace > 0
+        ? configuredGrace
+        : EXEC_KILL_GRACE_MS;
+    const stdoutSpec = {
+        path: `${SPILL_ROOT}/${randomUUID()}.stdout`,
+        maxBytes: spillBytes,
+    };
+    const stderrSpec = {
+        path: `${SPILL_ROOT}/${randomUUID()}.stderr`,
+        maxBytes: spillBytes,
+    };
+    return withGuestAuth(binding, (guest, token) => new Promise((resolveDone, reject) => {
+        const stdoutReader = outputReader({ maxBytes }, stdoutSpec);
+        const stderrReader = outputReader({ maxBytes }, stderrSpec);
+        if (stdoutReader === undefined || stderrReader === undefined) {
+            reject(new Error("exec output reader is unavailable"));
+            return;
+        }
+        const stream = guest.exec(metadata(token));
         let processId;
         let timer;
-        const stopTimer = () => {
+        let killTimer;
+        let settled = false;
+        let detach = () => { };
+        // settle runs one final action exactly once and tears down the timeout
+        // and the abort listener, so a timeout, an abort, and an exit cannot
+        // race. The kill timer deliberately outlives settle: it is the
+        // escalation for a command that ignored the cancellation's SIGTERM.
+        const settle = (finish) => {
+            if (settled)
+                return;
+            settled = true;
             if (timer !== undefined) {
                 clearTimeout(timer);
                 timer = undefined;
             }
+            detach();
+            finish();
+        };
+        const clearKillTimer = () => {
+            if (killTimer !== undefined) {
+                clearTimeout(killTimer);
+                killTimer = undefined;
+            }
+        };
+        const stopProcess = (sig) => {
+            if (processId === undefined)
+                return;
+            // Best effort: ask the guest to terminate the running process tree.
+            unaryGuest({ binding: { guest, token } }, "signal", {
+                processId,
+                signal: sig,
+            }).catch(() => { });
+        };
+        const cancelStream = () => {
+            try {
+                stream.cancel?.();
+            }
+            catch {
+                // The stream already ended; nothing to cancel.
+            }
+        };
+        // A cancellation asks the command to stop with SIGTERM, then kills its
+        // process group once the grace period elapses without an exit. The
+        // stream stays open for that grace so the guest still knows the process;
+        // the guest also escalates a cancelled stream to a group SIGKILL, so a
+        // lost connection stops the tree too.
+        const escalateStop = () => {
+            if (processId === undefined) {
+                // Nothing to signal yet: cancelling the stream is all that is left.
+                cancelStream();
+                return;
+            }
+            stopProcess("SIGTERM");
+            if (killTimer !== undefined)
+                return;
+            killTimer = setTimeout(() => {
+                killTimer = undefined;
+                stopProcess("SIGKILL");
+                cancelStream();
+            }, killGraceMs);
+            killTimer.unref?.();
+        };
+        const abortWith = (error) => {
+            escalateStop();
+            settle(() => reject(error));
         };
         if (typeof timeoutMs === "number" && timeoutMs > 0) {
             timer = setTimeout(() => {
                 timer = undefined;
-                if (processId !== undefined) {
-                    // Best effort: ask the guest to terminate the running process.
-                    unaryGuest({ binding }, "signal", {
-                        processId,
-                        signal: "SIGTERM",
-                    }).catch(() => { });
-                }
-                reject(new Error(`command timed out after ${timeoutMs} ms`));
+                abortWith(new Error(`command timed out after ${timeoutMs} ms`));
             }, timeoutMs);
         }
+        if (signal !== undefined) {
+            if (signal.aborted) {
+                abortWith(fsError("FS_ABORTED", "exec aborted"));
+                return;
+            }
+            const onAbort = () => abortWith(fsError("FS_ABORTED", "exec aborted"));
+            signal.addEventListener("abort", onAbort, { once: true });
+            detach = () => signal.removeEventListener("abort", onAbort);
+        }
         stream.on("data", (output) => {
             if (output.processId)
                 processId = String(output.processId);
-            if (output.stdoutChunk)
-                stdout.push(Buffer.from(output.stdoutChunk));
-            if (output.stderrChunk)
-                stderr.push(Buffer.from(output.stderrChunk));
+            if (output.stdoutChunk) {
+                stdoutReader.append(Buffer.from(output.stdoutChunk));
+            }
+            if (output.stderrChunk) {
+                stderrReader.append(Buffer.from(output.stderrChunk));
+            }
             if (output.exit) {
-                stopTimer();
-                resolveDone({
+                // The command stopped on its own within the grace period: nothing is
+                // left to escalate.
+                clearKillTimer();
+                stdoutReader.setSpillValid(Boolean(output.exit.stdoutSpillValid));
+                stderrReader.setSpillValid(Boolean(output.exit.stderrSpillValid));
+                const out = stdoutReader.readFrom(0);
+                const err = stderrReader.readFrom(0);
+                // A spill the in-memory tail already covered is deleted; a valid one
+                // holding dropped output stays for the caller to read.
+                discardUnneededSpill({ guest, token }, stdoutReader);
+                discardUnneededSpill({ guest, token }, stderrReader);
+                settle(() => resolveDone({
                     exitCode: output.exit.exitCode,
                     signal: output.exit.signaled ? output.exit.signal : null,
-                    stdout: Buffer.concat(stdout).toString("utf8"),
-                    stderr: Buffer.concat(stderr).toString("utf8"),
-                });
+                    stdout: out.text,
+                    stderr: err.text,
+                    ...(out.spillPath === undefined
+                        ? {}
+                        : { stdoutSpillPath: out.spillPath }),
+                    ...(err.spillPath === undefined
+                        ? {}
+                        : { stderrSpillPath: err.spillPath }),
+                }));
             }
         });
-        stream.on("error", (error) => {
-            stopTimer();
-            reject(error);
-        });
+        stream.on("error", (error) => settle(() => reject(error)));
+        stream.on("end", () => 
+        // A stream that ends without an exit message (guest restart, dropped
+        // socket) must not leave the caller pending forever.
+        settle(() => reject(new Error("exec stream ended before the process exited"))));
         stream.write({
             start: {
                 argv: remoteArgv(argv),
                 cwd,
                 env: env ?? {},
-                ...(identity?.uid !== undefined ? { uid: { value: identity.uid } } : {}),
-                ...(identity?.gid !== undefined ? { gid: { value: identity.gid } } : {}),
-                ...(identity?.groups !== undefined ? { groups: identity.groups } : {}),
+                ...(identity?.uid !== undefined
+                    ? { uid: { value: identity.uid } }
+                    : {}),
+                ...(identity?.gid !== undefined
+                    ? { gid: { value: identity.gid } }
+                    : {}),
+                ...(identity?.groups !== undefined
+                    ? { groups: identity.groups }
+                    : {}),
+                spillStdout: stdoutSpec,
+                spillStderr: stderrSpec,
             },
         });
         stream.end();
-    });
+    }));
 }
 // sliceLines returns the requested 1-based line range of a file's content,
 // defaulting to the first READ_LIMIT lines like the harness's read tool.
@@ -289,6 +461,45 @@ export function sliceLines(content, offset, limit) {
         : READ_LIMIT;
     return content.split("\n").slice(start - 1, start - 1 + max).join("\n");
 }
+// streamLines returns the requested 1-based line window of a text stream
+// without buffering the whole source. It matches sliceLines exactly — the
+// source is split on "\n", so a trailing newline keeps a final empty line —
+// while consuming only as much of the stream as the window needs.
+export async function streamLines(stream, offset, limit) {
+    const start = typeof offset === "number" && Number.isInteger(offset) && offset > 0
+        ? offset
+        : 1;
+    const max = typeof limit === "number" && Number.isInteger(limit) && limit > 0
+        ? limit
+        : READ_LIMIT;
+    const end = start - 1 + max;
+    const out = [];
+    let index = 0;
+    let carry = "";
+    let filled = false;
+    for await (const chunk of stream) {
+        carry += chunk;
+        let newline = carry.indexOf("\n");
+        while (newline >= 0) {
+            if (index >= start - 1 && index < end)
+                out.push(carry.slice(0, newline));
+            index++;
+            carry = carry.slice(newline + 1);
+            newline = carry.indexOf("\n");
+            if (index >= end) {
+                filled = true;
+                break;
+            }
+        }
+        if (filled)
+            break;
+    }
+    // The segment after the last newline, which split always keeps (possibly
+    // empty) when the stream ended before the window was filled.
+    if (!filled && index >= start - 1 && index < end)
+        out.push(carry);
+    return out.join("\n");
+}
 export function outputLines(text) {
     return text
         .split("\n")
@@ -305,14 +516,18 @@ export function currentCwd(exec) {
 }
 export async function sessionWorkspaceSlug(resolver, cwd) {
     const workspace = await resolver.registry?.resolveByPath?.(String(cwd));
-    if (workspace === undefined)
-        return "default";
+    if (workspace === undefined) {
+        // "default" is not a workspace slug, so returning it only produced an
+        // opaque orchestrator error downstream and a fabricated container_list
+        // row; fail with the same shape resolve() uses instead.
+        throw new Error(`cannot resolve a DH workspace without a session working directory (got ${JSON.stringify(cwd)})`);
+    }
     return workspaceSlug(workspace.id);
 }
-export async function resolveToolBinding(resolver, cwd, container) {
+export async function resolveToolBinding(resolver, cwd, container, signal) {
     if (container === "default")
-        return resolver.resolve(cwd);
-    return resolver.containerBinding(cwd, container);
+        return resolver.resolve(cwd, signal);
+    return resolver.containerBinding(cwd, container, signal);
 }
 export async function guestStat(target, signal) {
     const result = await guestStatResponse(target, signal);
@@ -326,29 +541,31 @@ export async function guestStat(target, signal) {
 }
 export function guestStatResponse(target, signal) {
     throwIfAborted(signal, "stat");
-    return new Promise((resolveDone, reject) => {
+    return withGuestAuth(target.binding, (guest, token) => new Promise((resolveDone, reject) => {
         let detach = () => { };
-        const call = target.binding.guest.stat({ path: target.targetKey }, metadata(target.binding.token), (error, value) => {
+        const call = guest.stat({ path: target.targetKey }, metadata(token), (error, value) => {
             detach();
             error
                 ? reject(signal?.aborted ? fsError("FS_ABORTED", "stat aborted") : error)
                 : resolveDone(value);
         });
         detach = onAbortCancel(call, signal);
-    });
+    }));
 }
 export async function unaryGuest(target, method, request, signal) {
     throwIfAborted(signal, method);
-    return new Promise((resolveDone, reject) => {
+    return withGuestAuth(target.binding, (guest, token) => new Promise((resolveDone, reject) => {
         let detach = () => { };
-        const call = target.binding.guest[method](request, metadata(target.binding.token), (error, result) => {
+        const call = guest[method](request, metadata(token), (error, result) => {
             detach();
             error
-                ? reject(signal?.aborted ? fsError("FS_ABORTED", `${method} aborted`) : error)
+                ? reject(signal?.aborted
+                    ? fsError("FS_ABORTED", `${method} aborted`)
+                    : error)
                 : resolveDone(result);
         });
         detach = onAbortCancel(call, signal);
-    });
+    }));
 }
 // globCwd returns the working directory a ripgrep discovery listing must run
 // in, or undefined to keep the caller's. The harness's glob tool passes its
@@ -359,8 +576,9 @@ export async function unaryGuest(target, method, request, signal) {
 // the harness renders against the session working directory.
 export function globCwd(argv, cwd) {
     const runner = argv[0];
-    if (runner === undefined || !/(?:^|\/)rg(?:\.exe)?$/.test(runner))
+    if (runner === undefined || !/(?:^|\/)rg(?:\.exe)?$/.test(runner)) {
         return undefined;
+    }
     if (!argv.includes("--files"))
         return undefined;
     const separator = argv.indexOf("--");
@@ -370,8 +588,9 @@ export function globCwd(argv, cwd) {
     if (roots.length !== 1)
         return undefined;
     const root = roots[0];
-    if (typeof cwd !== "string" || cwd === "" || !isAbsolute(root))
+    if (typeof cwd !== "string" || cwd === "" || !isAbsolute(root)) {
         return undefined;
+    }
     return root;
 }
 // remoteArgv rewrites an argv for the guest's execution world: the harness's

package/dist/guest-rpc.test.d.ts

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