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

package/dist/test-support.js

@@ -8,11 +8,27 @@ import { createFilesystemProvider } from "./index.js";
 export const WORKSPACE_ID = "2c573001-4171-4900-904b-12a5cc02737a";
 export class FakeTerminalCall extends EventEmitter {
     stdinChunks = [];
+    resizes = [];
+    start;
+    closed = false;
+    ended = false;
     write(message) {
+        if (message.close) {
+            this.closed = true;
+            return;
+        }
         if (message.start) {
+            this.start = message.start;
             queueMicrotask(() => this.emit("data", { started: { pid: 42 } }));
             return;
         }
+        if (message.resize) {
+            this.resizes.push({
+                rows: message.resize.rows,
+                cols: message.resize.cols,
+            });
+            return;
+        }
         if (message.stdinChunk) {
             this.stdinChunks.push(Buffer.from(message.stdinChunk));
             return;
@@ -20,7 +36,12 @@ export class FakeTerminalCall extends EventEmitter {
         if (message.inspectRequestId !== undefined) {
             const requestId = message.inspectRequestId;
             queueMicrotask(() => this.emit("data", {
-                foreground: { requestId, found: true, processGroupId: 7, inputWaiting: true },
+                foreground: {
+                    requestId,
+                    found: true,
+                    processGroupId: 7,
+                    inputWaiting: true,
+                },
             }));
             return;
         }
@@ -31,7 +52,9 @@ export class FakeTerminalCall extends EventEmitter {
             }));
         }
     }
-    end() { }
+    end() {
+        this.ended = true;
+    }
     cancel() { }
     emitStdout(data) {
         this.emit("data", { stdoutChunk: data });
@@ -98,7 +121,9 @@ export const sessionExec = (name, facts = { mode: "read-only" }) => ({
 export const presetExec = (name, preset, args, facts = {}) => ({
     name,
     arguments: args,
-    agent: { session: { header: { agentPreset: preset }, facts: { ...facts, preset } } },
+    agent: {
+        session: { header: { agentPreset: preset }, facts: { ...facts, preset } },
+    },
 });
 export const MOUNT_TOOLS = [
     "container_mount_list",
@@ -146,7 +171,11 @@ export const SECRET_BEARING_CONTAINER = {
     agentSocketPath: `/run/dsh-podman/${WORKSPACE_ID}-default/guest.sock`,
     agentToken: "super-secret-token",
     mounts: [
-        { projectName: "team", mode: "MOUNT_MODE_READ_WRITE", kind: "MOUNT_KIND_PROJECT" },
+        {
+            projectName: "team",
+            mode: "MOUNT_MODE_READ_WRITE",
+            kind: "MOUNT_KIND_PROJECT",
+        },
     ],
     env: { PATH: "/bin", DB_PASSWORD: "hunter2" },
     secretEnv: { DB_PASS: "db-pass" },
@@ -200,8 +229,9 @@ export function guestFileRecorder(content = "hello", exists = true) {
                 write(message) {
                     if (message.start !== undefined)
                         path = message.start.path;
-                    if (message.dataChunk !== undefined)
+                    if (message.dataChunk !== undefined) {
                         body += String(message.dataChunk);
+                    }
                 },
                 end() {
                     writes.push({ path, content: body });
@@ -264,8 +294,9 @@ export function guestExecRecorder(defaultCwd, stdout) {
                 },
                 end() {
                     for (const handler of handlers.data ?? []) {
-                        if (stdout !== undefined)
+                        if (stdout !== undefined) {
                             handler({ stdoutChunk: Buffer.from(stdout) });
+                        }
                         handler({ exit: { exitCode: 0, signaled: false } });
                     }
                 },
@@ -381,36 +412,61 @@ export function editProvider(binding) {
         resolveForPath: async () => binding,
     });
 }
+// The guest Exec bidi stream the subprocess provider drives, with the
+// backpressure and failure controls its tests need. `write()` records the start
+// message; `end()` replays the process id, the configured stdout and (unless
+// disabled) the exit message, mirroring a guest that answered immediately.
+export class FakeExecStream extends EventEmitter {
+    starts;
+    options;
+    paused = 0;
+    resumed = 0;
+    cancelled = false;
+    constructor(starts, options) {
+        super();
+        this.starts = starts;
+        this.options = options;
+    }
+    write(message) {
+        this.starts.push(message);
+        return true;
+    }
+    end() {
+        this.emitData({ processId: "7" });
+        if (this.options.stdout !== undefined) {
+            this.emitData({ stdoutChunk: Buffer.from(this.options.stdout) });
+        }
+        if (this.options.emitExit !== false) {
+            this.emitData({
+                exit: { exitCode: 0, signaled: false, ...this.options.exit },
+            });
+        }
+    }
+    pause() {
+        this.paused++;
+    }
+    resume() {
+        this.resumed++;
+    }
+    cancel() {
+        this.cancelled = true;
+    }
+    emitData(message) {
+        this.emit("data", message);
+    }
+}
 // A fake guest for the subprocess provider: exec emits a process id (and
 // optionally an exit), and the unary signal/delete RPCs are recorded.
 export function spawnGuest(options = {}) {
     const signals = [];
     const starts = [];
     const deletes = [];
+    const streams = [];
     const guest = {
         exec: () => {
-            const handlers = {};
-            return {
-                on(event, handler) {
-                    (handlers[event] ??= []).push(handler);
-                },
-                write(message) {
-                    starts.push(message);
-                },
-                end() {
-                    for (const handler of handlers.data ?? []) {
-                        handler({ processId: "7" });
-                        if (options.stdout !== undefined) {
-                            handler({ stdoutChunk: Buffer.from(options.stdout) });
-                        }
-                        if (options.emitExit !== false) {
-                            handler({
-                                exit: { exitCode: 0, signaled: false, ...options.exit },
-                            });
-                        }
-                    }
-                },
-            };
+            const stream = new FakeExecStream(starts, options);
+            streams.push(stream);
+            return stream;
         },
         signal: (request, _metadata, callback) => {
             signals.push(request);
@@ -425,13 +481,19 @@ export function spawnGuest(options = {}) {
         signals,
         starts,
         deletes,
+        streams,
+        guest,
         resolver: { resolve: async () => ({ guest, token: "t" }) },
     };
 }
 export const spawnSpec = (overrides = {}) => ({
     argv: ["sleep", "1"],
     cwd: "/projects/team",
-    stdio: { stdin: "ignore", stdout: { maxBytes: 10 }, stderr: { maxBytes: 10 } },
+    stdio: {
+        stdin: "ignore",
+        stdout: { maxBytes: 10 },
+        stderr: { maxBytes: 10 },
+    },
     graceMs: 50,
     ...overrides,
 });

package/dist/tool-defs.js

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
 //
 // SPDX-License-Identifier: MIT
-import { containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerMountUpdateParameters, containerPathAddParameters, containerPathRemoveParameters, containerPathSetParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, volumeCreateParameters, volumeListParameters, volumeRemoveParameters } from "./tool-params.js";
+import { containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerMountUpdateParameters, containerPathAddParameters, containerPathRemoveParameters, containerPathSetParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, volumeCreateParameters, volumeListParameters, volumeRemoveParameters, } from "./tool-params.js";
 export function defineTool(definition) {
     return definition;
 }
@@ -9,6 +9,16 @@ export const toolOutput = {
     schema: { type: "string" },
     render: (_args, value) => [{ type: "text", text: value }],
 };
+// hasSecretEnv reports whether a call attaches secrets to a container. Unlike
+// plain `env`, a secret env var injects a value the caller never sees, so
+// container_start must be approved for it exactly like container_secret_add.
+function hasSecretEnv(args) {
+    const secretEnv = args.secretEnv;
+    return (typeof secretEnv === "object" &&
+        secretEnv !== null &&
+        !Array.isArray(secretEnv) &&
+        Object.keys(secretEnv).length > 0);
+}
 export const TOOLS = [
     { name: "image_list", parameters: imageListParameters },
     { name: "image_get", parameters: imageGetParameters },
@@ -28,14 +38,19 @@ export const TOOLS = [
     {
         name: "container_start",
         parameters: containerStartParameters,
-        approvalWhen: (args) => Array.isArray(args.mounts) && args.mounts.length > 0,
+        approvalWhen: (args) => (Array.isArray(args.mounts) && args.mounts.length > 0) ||
+            hasSecretEnv(args),
     },
     {
         name: "container_recreate",
         parameters: containerRecreateParameters,
         approval: true,
     },
-    { name: "container_remove", parameters: containerRemoveParameters, approval: true },
+    {
+        name: "container_remove",
+        parameters: containerRemoveParameters,
+        approval: true,
+    },
     { name: "container_bash", parameters: containerBashParameters },
     { name: "container_exec", parameters: containerExecParameters },
     { name: "container_read", parameters: containerReadParameters },
@@ -122,7 +137,7 @@ export const TOOL_DESCRIPTIONS = {
     container_read: "Read a file inside a container of the current workspace.",
     container_write: "Write a file inside a container of the current workspace.",
     container_edit: "Edit a file inside a container of the current workspace.",
-    container_glob: "List files inside a container of the current workspace matching a glob pattern. A pattern with no \"/\" matches basenames at any depth. Results are files only, include hidden and ignored files, and exclude VCS metadata directories. Defaults to the session working directory when it is mounted; pass path to override.",
+    container_glob: 'List files inside a container of the current workspace matching a glob pattern. A pattern with no "/" matches basenames at any depth. Results are files only, include hidden and ignored files, and exclude VCS metadata directories. Defaults to the session working directory when it is mounted; pass path to override.',
     container_grep: "Search file contents inside a container of the current workspace. Defaults to the session working directory when it is mounted; pass cwd to override.",
     container_mount_list: "List the mounts of a container in the current workspace, with the exact kind, project, volume, secret, and destination values to pass to container_mount_remove.",
     container_mount_add: "Add a mount to a container in the current workspace: a project bind (project, a path under the projects root), a tmpfs, a named volume, or a secret, selected by kind (default project). Recreates the container, terminating its running processes; bind-mounted volume data persists. Requires approval: adding a mount changes the container filesystem view.",

package/dist/tool-handlers.js

@@ -1,11 +1,12 @@
 // SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
 //
 // SPDX-License-Identifier: MIT
-import { bytesText, currentCwd, fsError, guestCwd, outputLines, resolveToolBinding, runExec, sessionWorkspaceSlug, sliceLines, unaryGuest, } from "./guest-rpc.js";
-import { inferMountKind, mountsFromInput, projectMountDestinationReason } from "./mount-input.js";
-import { publicContainer, publicDaemon, publicImage, publicMount } from "./public.js";
+import { bytesText, currentCwd, fsError, guestCwd, outputLines, resolveToolBinding, runExec, sessionWorkspaceSlug, streamLines, unaryGuest, } from "./guest-rpc.js";
+import { inferMountKind, mountsFromInput, projectMountDestinationReason, } from "./mount-input.js";
+import { mergeDefaultEnv } from "./container-env.js";
+import { publicContainer, publicDaemon, publicImage, publicMount, } from "./public.js";
 import { grpc } from "./grpc/runtime-client.js";
-import { defaultMountMode, mountKindToProto, mountModeToProto } from "./mount-enums.js";
+import { defaultMountMode, mountKindToProto, mountModeToProto, } from "./mount-enums.js";
 import { containerNotFound, } from "./workspace-binding.js";
 // Cap on paths `container_glob` returns, matching the built-in glob tool's
 // default result limit; `--sort=modified` makes the retained head the newest.
@@ -22,6 +23,18 @@ function failOnSearchError(tool, result) {
     const detail = result.stderr.trim();
     throw new Error(detail === "" ? `${tool} search failed (ripgrep exit code 2)` : detail);
 }
+// withSpillNote points the caller at the guest spill file when a command's
+// output was truncated in memory, so the full stream stays reachable with
+// container_read instead of silently vanishing.
+function withSpillNote(result) {
+    const paths = [result.stdoutSpillPath, result.stderrSpillPath].filter((path) => typeof path === "string");
+    if (paths.length === 0)
+        return result;
+    return {
+        ...result,
+        note: `output was truncated; the full stream is at ${paths.join(", ")} (read it with container_read)`,
+    };
+}
 // The terminal environment the harness's shell executors impose on every
 // command (`ENV_OVERRIDES` in dsh-bash-local), so a container command sees the
 // same non-interactive terminal as the built-in `bash`.
@@ -39,7 +52,32 @@ const ENV_OVERRIDES = {
 // collects it through `ctx.shellEnv`.
 function managedEnv(ctx, exec, env) {
     const managed = ctx?.get?.("shellEnv")?.collect?.(exec) ?? {};
-    return { ...ENV_OVERRIDES, ...env, ...managed };
+    return {
+        ...ENV_OVERRIDES,
+        ...env,
+        ...managed,
+    };
+}
+// startContainerEnv resolves the environment a `container_start` request
+// carries. The caller's map wins over the defaults; a container that does not
+// exist yet is a creation and gets the defaults alone; one that already exists
+// keeps the environment it has (the orchestrator preserves a stored env when
+// the request omits one, so nothing has to be sent).
+async function startContainerEnv(resolver, slug, input) {
+    const defaults = resolver.getConfig().containerEnv;
+    if (input.env !== undefined) {
+        return mergeDefaultEnv(defaults, input.env);
+    }
+    if (defaults === undefined || Object.keys(defaults).length === 0) {
+        return undefined;
+    }
+    const result = await resolver.control("listContainers", {});
+    const name = input.container === "" ? "default" : input.container;
+    const exists = (result.containers ?? []).some((row) => row.workspaceSlug === slug && row.containerName === name);
+    if (exists)
+        return undefined;
+    const env = mergeDefaultEnv(defaults, undefined);
+    return Object.keys(env).length === 0 ? undefined : env;
 }
 // containerTarget resolves a container-scoped file target through the plugin's
 // own filesystem provider, so the container file tools share the harness's file
@@ -123,12 +161,14 @@ export const toolHandlers = {
     },
     container_start: async (resolver, input, exec) => {
         const mounts = mountsFromInput(input.mounts, resolver.getConfig().projectsRoot);
+        const slug = await sessionWorkspaceSlug(resolver, currentCwd(exec));
+        const env = await startContainerEnv(resolver, slug, input);
         const row = await resolver.control("startContainer", {
-            workspaceSlug: await sessionWorkspaceSlug(resolver, currentCwd(exec)),
+            workspaceSlug: slug,
             container: input.container,
             imageId: input.image,
             ...(mounts === undefined ? {} : { mounts }),
-            ...(input.env !== undefined ? { env: input.env } : {}),
+            ...(env === undefined ? {} : { env }),
             ...(input.secretEnv !== undefined ? { secretEnv: input.secretEnv } : {}),
             ...(input.paths !== undefined ? { paths: input.paths } : {}),
         });
@@ -156,13 +196,13 @@ export const toolHandlers = {
     },
     container_bash: async (resolver, input, exec, ctx) => {
         const sessionCwd = currentCwd(exec);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
-        return runExec(binding, ["bash", "-c", input.command], guestCwd(input.workdir, sessionCwd, binding), managedEnv(ctx, exec, input.env), input.timeoutMs, identityFromInput(input));
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
+        return withSpillNote(await runExec(binding, ["bash", "-c", input.command], guestCwd(input.workdir, sessionCwd, binding), managedEnv(ctx, exec, input.env), input.timeoutMs, identityFromInput(input), { signal: exec?.signal }));
     },
     container_exec: async (resolver, input, exec, ctx) => {
         const sessionCwd = currentCwd(exec);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
-        return runExec(binding, input.argv, guestCwd(input.workdir, sessionCwd, binding), managedEnv(ctx, exec, input.env), input.timeoutMs, identityFromInput(input));
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
+        return withSpillNote(await runExec(binding, input.argv, guestCwd(input.workdir, sessionCwd, binding), managedEnv(ctx, exec, input.env), input.timeoutMs, identityFromInput(input), { signal: exec?.signal }));
     },
     container_read: async (resolver, input, exec, ctx) => {
         const target = await containerTarget(ctx, input.file_path, input.container, exec);
@@ -178,9 +218,11 @@ export const toolHandlers = {
         if (info.type !== "file") {
             throw fsError("FS_NOT_REGULAR_FILE", `cannot read "${target.displayPath}": not a regular file`);
         }
-        const content = await ctx.fs.readText(target, exec?.signal);
+        // Stream the requested line window instead of buffering the whole file:
+        // a read of a few lines from a huge file must not read it all into memory.
+        const lines = await streamLines(await ctx.fs.streamText(target, exec?.signal), input.offset, input.limit);
         ctx.emit("fs/observed", target, { kind: "present", version: info.version }, exec);
-        return sliceLines(content, input.offset, input.limit);
+        return lines;
     },
     container_write: async (resolver, input, exec, ctx) => {
         const target = await containerTarget(ctx, input.file_path, input.container, exec);
@@ -190,7 +232,10 @@ export const toolHandlers = {
         const intent = await ctx.waterfall("fs/write-intent", target, exec, () => undefined);
         const content = String(input.content ?? "");
         const outcome = await ctx.fs.writeText(target, content, intent, exec?.signal);
-        ctx.emit("fs/observed", target, { kind: "present", version: outcome.version }, exec);
+        ctx.emit("fs/observed", target, {
+            kind: "present",
+            version: outcome.version,
+        }, exec);
         return { bytesWritten: Buffer.byteLength(content, "utf8") };
     },
     container_edit: async (resolver, input, exec, ctx) => {
@@ -201,12 +246,15 @@ export const toolHandlers = {
             newString: input.new_string,
             replaceAll: input.replace_all === true,
         }, intent, exec?.signal);
-        ctx.emit("fs/observed", target, { kind: "present", version: outcome.version }, exec);
+        ctx.emit("fs/observed", target, {
+            kind: "present",
+            version: outcome.version,
+        }, exec);
         return { before: outcome.before, after: outcome.after };
     },
     container_glob: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const argv = [
             "rg",
             "--files",
@@ -219,7 +267,7 @@ export const toolHandlers = {
                 `--glob=!**/${name}/**`,
             ]),
         ];
-        const result = await runExec(binding, argv, guestCwd(input.path, sessionCwd, binding));
+        const result = await runExec(binding, argv, guestCwd(input.path, sessionCwd, binding), undefined, undefined, undefined, { signal: exec?.signal });
         failOnSearchError("glob", result);
         const files = outputLines(result.stdout);
         const capped = files.length > GLOB_MAX_RESULTS;
@@ -234,7 +282,7 @@ export const toolHandlers = {
     },
     container_grep: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const cwd = guestCwd(undefined, sessionCwd, binding);
         // The search root: the requested path, else the container's default (the
         // session workspace when it is mounted). Ripgrep reads stdin instead of the
@@ -247,7 +295,9 @@ export const toolHandlers = {
         argv.push(input.pattern);
         if (root !== undefined)
             argv.push(root);
-        const result = await runExec(binding, argv, cwd);
+        const result = await runExec(binding, argv, cwd, undefined, undefined, undefined, {
+            signal: exec?.signal,
+        });
         failOnSearchError("grep", result);
         return {
             matches: outputLines(result.stdout),
@@ -356,7 +406,7 @@ export const toolHandlers = {
     container_path_set: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
         const slug = await sessionWorkspaceSlug(resolver, sessionCwd);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const paths = Array.isArray(input.paths) ? input.paths.map(String) : [];
         return {
             paths: await applyContainerPaths(resolver, binding, slug, input.container, paths),
@@ -365,7 +415,7 @@ export const toolHandlers = {
     container_path_add: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
         const slug = await sessionWorkspaceSlug(resolver, sessionCwd);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const current = await containerPathState(binding);
         // Prepending gives the new path the highest priority; an existing entry is
         // moved to the front rather than duplicated.
@@ -380,7 +430,7 @@ export const toolHandlers = {
     container_path_remove: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
         const slug = await sessionWorkspaceSlug(resolver, sessionCwd);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const current = await containerPathState(binding);
         if (!current.paths.includes(input.path)) {
             if (current.defaultPaths.includes(input.path)) {
@@ -440,7 +490,7 @@ export const toolHandlers = {
     },
     daemon_start: async (resolver, input, exec) => {
         const sessionCwd = currentCwd(exec);
-        const binding = await resolveToolBinding(resolver, sessionCwd, input.container);
+        const binding = await resolveToolBinding(resolver, sessionCwd, input.container, exec?.signal);
         const request = {
             argv: input.argv,
             inheritEnv: { value: input.inheritEnv !== false },
@@ -463,12 +513,12 @@ export const toolHandlers = {
         return publicDaemon(info);
     },
     daemon_list: async (resolver, input, exec) => {
-        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container);
+        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container, exec?.signal);
         const result = (await unaryGuest({ binding }, "listDaemons", {}));
         return (result.daemons ?? []).map(publicDaemon);
     },
     daemon_stop: async (resolver, input, exec) => {
-        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container);
+        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container, exec?.signal);
         await daemonCall(input.name, () => unaryGuest({ binding }, "stopDaemon", {
             name: input.name,
             signal: input.signal,
@@ -476,12 +526,12 @@ export const toolHandlers = {
         return { stopped: input.name };
     },
     daemon_restart: async (resolver, input, exec) => {
-        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container);
+        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container, exec?.signal);
         const info = await daemonCall(input.name, () => unaryGuest({ binding }, "restartDaemon", { name: input.name }));
         return publicDaemon(info);
     },
     daemon_logs: async (resolver, input, exec) => {
-        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container);
+        const binding = await resolveToolBinding(resolver, currentCwd(exec), input.container, exec?.signal);
         const result = (await daemonCall(input.name, () => unaryGuest({ binding }, "daemonLogs", {
             name: input.name,
             tailBytes: input.tailBytes,
@@ -504,7 +554,9 @@ async function containerPathState(binding) {
     const paths = Array.isArray(result?.paths)
         ? result.paths.map((path) => String(path))
         : [];
-    const defaultPath = typeof result?.defaultPath === "string" ? result.defaultPath : "";
+    const defaultPath = typeof result?.defaultPath === "string"
+        ? result.defaultPath
+        : "";
     return {
         paths,
         defaultPaths: defaultPath === "" ? [] : defaultPath.split(":"),

package/dist/tool-params.js

@@ -136,7 +136,11 @@ export const containerStartParameters = {
         },
         mounts: mountsParam,
         env: envParam,
-        secretEnv: { type: "object", additionalProperties: { type: "string" }, description: "Secret environment variables (env var name to secret short name)." },
+        secretEnv: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Secret environment variables (env var name to secret short name).",
+        },
         paths: pathsParam,
     },
     required: ["container"],
@@ -151,7 +155,11 @@ export const containerRecreateParameters = {
         },
         mounts: mountsParam,
         env: envParam,
-        secretEnv: { type: "object", additionalProperties: { type: "string" }, description: "Secret environment variables (env var name to secret short name)." },
+        secretEnv: {
+            type: "object",
+            additionalProperties: { type: "string" },
+            description: "Secret environment variables (env var name to secret short name).",
+        },
         paths: pathsParam,
     },
     required: ["container"],
@@ -272,12 +280,16 @@ export const volumeListParameters = {
 };
 export const volumeCreateParameters = {
     type: "object",
-    properties: { name: { type: "string", description: "Volume name to create." } },
+    properties: {
+        name: { type: "string", description: "Volume name to create." },
+    },
     required: ["name"],
 };
 export const volumeRemoveParameters = {
     type: "object",
-    properties: { name: { type: "string", description: "Volume name to remove." } },
+    properties: {
+        name: { type: "string", description: "Volume name to remove." },
+    },
     required: ["name"],
 };
 export const secretListParameters = {
@@ -304,7 +316,9 @@ export const secretCreateParameters = {
 };
 export const secretRemoveParameters = {
     type: "object",
-    properties: { name: { type: "string", description: "Secret name to remove." } },
+    properties: {
+        name: { type: "string", description: "Secret name to remove." },
+    },
     required: ["name"],
 };
 export const containerSecretAddParameters = {

package/dist/version-compat.d.ts

@@ -0,0 +1,4 @@
+export type VersionState = "ok" | "minor-mismatch" | "major-mismatch";
+export declare function core(value: string): string;
+export declare function major(value: string): number;
+export declare function versionState(plugin: string, orchestrator: string): VersionState;

package/dist/version-compat.js

@@ -0,0 +1,29 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// core returns the leading x.y.z of a version string, or "" when there is
+// none. A release build is exactly the tag; a build from a later commit carries
+// a git-describe suffix (`1.2.3-4-gabc123`), and a local build may be `dev`.
+export function core(value) {
+    const match = /^(\d+)\.(\d+)\.(\d+)/.exec(String(value ?? ""));
+    return match === null ? "" : `${match[1]}.${match[2]}.${match[3]}`;
+}
+// major returns the major component of a version's core, or -1 when the value
+// has no parseable core.
+export function major(value) {
+    const parsed = core(value);
+    return parsed === "" ? -1 : Number(parsed.slice(0, parsed.indexOf(".")));
+}
+// versionState mirrors the orchestrator's own compatibility rule, so the card
+// reports exactly what the control plane enforces.
+export function versionState(plugin, orchestrator) {
+    const orchestratorCore = core(orchestrator);
+    if (orchestratorCore === "")
+        return "ok";
+    const pluginCore = core(plugin);
+    if (pluginCore === "")
+        return "major-mismatch";
+    if (major(plugin) !== major(orchestrator))
+        return "major-mismatch";
+    return pluginCore === orchestratorCore ? "ok" : "minor-mismatch";
+}

package/dist/version-compat.test.d.ts

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

package/dist/version-compat.test.js

@@ -0,0 +1,27 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import test from "node:test";
+import assert from "node:assert/strict";
+import { core, major, versionState } from "./version-compat.js";
+test("core keeps the leading x.y.z", () => {
+    assert.equal(core("1.2.3"), "1.2.3");
+    assert.equal(core("0.2.0-rc.3"), "0.2.0");
+    assert.equal(core("1.2.3-4-gabc123"), "1.2.3");
+    assert.equal(core("dev"), "");
+    assert.equal(core(""), "");
+});
+test("major reports the leading component", () => {
+    assert.equal(major("1.2.3"), 1);
+    assert.equal(major("0.2.0-rc.3"), 0);
+    assert.equal(major("dev"), -1);
+});
+test("versionState mirrors the orchestrator's compatibility rule", () => {
+    assert.equal(versionState("1.2.3", "1.2.3"), "ok");
+    assert.equal(versionState("1.2.3-4-gabc", "1.2.3"), "ok");
+    assert.equal(versionState("1.3.0", "1.2.3"), "minor-mismatch");
+    assert.equal(versionState("1.2.4", "1.2.3"), "minor-mismatch");
+    assert.equal(versionState("2.0.0", "1.9.0"), "major-mismatch");
+    assert.equal(versionState("1.9.0", "2.0.0"), "major-mismatch");
+    assert.equal(versionState("1.2.3", "dev"), "ok", "an orchestrator with no comparable version accepts any plugin");
+});

package/dist/volumes.test.js

@@ -4,7 +4,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { VOLUME_TOOLS } from "./test-support.js";
-import { TOOLS, toolHandlers } from "./index.js";
+import { toolHandlers, TOOLS } from "./index.js";
 test("volume tools are registered with the expected schemas", () => {
     for (const name of VOLUME_TOOLS) {
         const tool = TOOLS.find((entry) => entry.name === name);