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

package/dist/guest-rpc.test.js

@@ -0,0 +1,241 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { runExec, sessionWorkspaceSlug, sliceLines, streamLines, withGuestAuth, } from "./guest-rpc.js";
+import { grpc } from "./grpc/runtime-client.js";
+// pingOnce is a stand-in for a real guest call: it invokes the guest client and
+// settles from its callback.
+function pingOnce(guest, _token) {
+    return new Promise((resolve, reject) => {
+        guest.ping({}, undefined, (error, value) => error ? reject(error) : resolve(value));
+    });
+}
+function rejectingGuest() {
+    return {
+        guest: {
+            ping: (_request, _metadata, callback) => callback(Object.assign(new Error("invalid agent token"), {
+                code: grpc.status.UNAUTHENTICATED,
+            })),
+        },
+        token: "old",
+    };
+}
+test("withGuestAuth retries once with a refreshed binding", async () => {
+    const seen = [];
+    const fresh = {
+        guest: {
+            ping: (_request, _metadata, callback) => callback(null, { version: "v" }),
+        },
+        token: "new",
+    };
+    const binding = { ...rejectingGuest(), refresh: async () => fresh };
+    const result = await withGuestAuth(binding, (guest, token) => {
+        seen.push(token);
+        return pingOnce(guest, token);
+    });
+    assert.deepEqual(seen, ["old", "new"]);
+    assert.deepEqual(result, { version: "v" });
+});
+test("withGuestAuth surfaces a second rejection", async () => {
+    const rejecting = rejectingGuest();
+    const binding = { ...rejecting, refresh: async () => rejecting };
+    await assert.rejects(() => withGuestAuth(binding, pingOnce), /invalid agent token/);
+});
+test("withGuestAuth does not refresh on a non-auth error", async () => {
+    let refreshed = false;
+    const binding = {
+        guest: {
+            ping: (_request, _metadata, callback) => callback(Object.assign(new Error("boom"), { code: grpc.status.INTERNAL })),
+        },
+        token: "t",
+        refresh: async () => {
+            refreshed = true;
+            return binding;
+        },
+    };
+    await assert.rejects(() => withGuestAuth(binding, pingOnce), /boom/);
+    assert.equal(refreshed, false);
+});
+test("withGuestAuth surfaces the error when the binding cannot refresh", async () => {
+    const binding = rejectingGuest();
+    await assert.rejects(() => withGuestAuth(binding, pingOnce), /invalid agent token/);
+});
+// FakeExecStream is the guest Exec bidi stream a real channel would give us.
+class FakeExecStream extends EventEmitter {
+    written = [];
+    ended = false;
+    cancelled = false;
+    write(message) {
+        this.written.push(message);
+        return true;
+    }
+    end() {
+        this.ended = true;
+    }
+    cancel() {
+        this.cancelled = true;
+    }
+}
+// execGuest returns a guest double driving one FakeExecStream. `signal` and
+// `delete` are the calls runExec makes for cancellation and spill cleanup.
+function execGuest(stream) {
+    const signals = [];
+    return {
+        stream,
+        signals,
+        guest: {
+            exec: () => stream,
+            signal: (request, _metadata, callback) => {
+                signals.push(request.signal);
+                callback(null, {});
+            },
+            delete: (_request, _metadata, callback) => callback(null, {}),
+        },
+    };
+}
+const EXIT_OK = {
+    exitCode: 0,
+    signaled: false,
+    stdoutSpillValid: true,
+    stderrSpillValid: true,
+};
+test("runExec resolves on exit and asks the guest for a spill copy", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const promise = runExec(binding, ["echo", "hi"]);
+    harness.stream.emit("data", { processId: "1" });
+    harness.stream.emit("data", { stdoutChunk: Buffer.from("hi\n") });
+    harness.stream.emit("data", { exit: EXIT_OK });
+    const result = await promise;
+    assert.equal(result.exitCode, 0);
+    assert.equal(result.stdout, "hi\n");
+    const start = harness.stream.written[0].start;
+    assert.match(start.spillStdout.path, /^\/tmp\/dsh-podman\/[0-9a-f-]+\.stdout$/);
+    assert.equal(start.spillStderr.path.endsWith(".stderr"), true);
+    // The output fit in memory, so the spill file is deleted again.
+    assert.equal(result.stdoutSpillPath, undefined);
+});
+test("runExec rejects when the stream ends without an exit message", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const promise = runExec(binding, ["hang"]);
+    harness.stream.emit("end");
+    await assert.rejects(promise, /ended before the process exited/);
+});
+test("runExec aborts with the turn signal, then escalates to SIGKILL", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const controller = new AbortController();
+    const promise = runExec(binding, ["sleep", "99"], undefined, undefined, undefined, undefined, {
+        signal: controller.signal,
+        killGraceMs: 60,
+    });
+    harness.stream.emit("data", { processId: "7" });
+    controller.abort();
+    await assert.rejects(promise, /aborted/);
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(harness.signals, ["SIGTERM"]);
+    // The stream stays open for the grace period, so a command that ignores
+    // SIGTERM can still be killed by its process group.
+    assert.equal(harness.stream.cancelled, false);
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    assert.deepEqual(harness.signals, ["SIGTERM", "SIGKILL"]);
+    assert.equal(harness.stream.cancelled, true);
+});
+test("runExec leaves a command that exits within the grace period alone", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const controller = new AbortController();
+    const promise = runExec(binding, ["sleep", "99"], undefined, undefined, undefined, undefined, {
+        signal: controller.signal,
+        killGraceMs: 30,
+    });
+    harness.stream.emit("data", { processId: "7" });
+    controller.abort();
+    await assert.rejects(promise, /aborted/);
+    harness.stream.emit("data", { exit: EXIT_OK });
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    assert.deepEqual(harness.signals, ["SIGTERM"]);
+    assert.equal(harness.stream.cancelled, false);
+});
+test("runExec cancels an abort that arrives before the process id", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const controller = new AbortController();
+    const promise = runExec(binding, ["sleep", "99"], undefined, undefined, undefined, undefined, {
+        signal: controller.signal,
+    });
+    controller.abort();
+    await assert.rejects(promise, /aborted/);
+    assert.equal(harness.stream.cancelled, true);
+    assert.deepEqual(harness.signals, []);
+});
+test("runExec rejects a pre-aborted call without starting it", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const controller = new AbortController();
+    controller.abort();
+    await assert.rejects(() => runExec(binding, ["x"], undefined, undefined, undefined, undefined, {
+        signal: controller.signal,
+    }), /aborted/);
+    assert.equal(harness.stream.written.length, 0);
+});
+test("runExec keeps a bounded tail and points at the spill on truncation", async () => {
+    const harness = execGuest(new FakeExecStream());
+    const binding = { guest: harness.guest, token: "t" };
+    const promise = runExec(binding, ["big"], undefined, undefined, undefined, undefined, {
+        maxBytes: 4,
+        spillBytes: 1024,
+    });
+    harness.stream.emit("data", { stdoutChunk: Buffer.from("0123456789") });
+    harness.stream.emit("data", { exit: EXIT_OK });
+    const result = await promise;
+    assert.equal(result.stdout, "6789", "only the bounded tail is retained");
+    assert.match(result.stdoutSpillPath ?? "", /^\/tmp\/dsh-podman\/[0-9a-f-]+\.stdout$/);
+});
+test("sessionWorkspaceSlug fails instead of fabricating a default workspace", async () => {
+    const resolver = { registry: { resolveByPath: async () => undefined } };
+    await assert.rejects(() => sessionWorkspaceSlug(resolver, "/projects/gone"), /cannot resolve a DH workspace/);
+});
+// chunks yields one character at a time, the worst case for a streaming line
+// reader because every boundary can fall inside a line.
+async function* characters(content) {
+    for (const character of content)
+        yield character;
+}
+test("streamLines matches sliceLines for every window shape", async () => {
+    const cases = [
+        ["", 1, 5],
+        ["a", 1, 5],
+        ["a\n", 1, 5],
+        ["a\nb\nc", 1, 2],
+        ["a\nb\nc\n", 1, 2],
+        ["a\nb\nc\n", 2, 2],
+        ["a\nb\nc\n", 2, 10],
+        ["a\nb", 2, 2],
+        ["a\nb", 5, 2],
+        ["x\ny\nz\n", 3, 10],
+        ["1\n2\n3\n4\n5", 2, 3],
+        ["\n\n\n", 2, 2],
+    ];
+    for (const [content, offset, limit] of cases) {
+        const expected = sliceLines(content, offset, limit);
+        const streamed = await streamLines(characters(content), offset, limit);
+        assert.equal(streamed, expected, `content=${JSON.stringify(content)} offset=${offset} limit=${limit}`);
+    }
+});
+test("streamLines stops consuming once the window is filled", async () => {
+    let consumed = 0;
+    async function* source() {
+        for (let index = 1; index <= 100; index++) {
+            consumed++;
+            yield `${index}\n`;
+        }
+    }
+    const out = await streamLines(source(), 1, 2);
+    assert.equal(out, "1\n2");
+    assert.equal(consumed, 2);
+});

package/dist/guest-terminal.d.ts

@@ -0,0 +1,30 @@
+import { type WorkspaceBinding } from "./workspace-binding.js";
+export interface GuestTerminalOptions {
+    argv: readonly string[];
+    cwd: string;
+    env?: Readonly<Record<string, string>>;
+    cols: number;
+    rows: number;
+    terminalType?: string;
+}
+export interface GuestTerminalExit {
+    exitCode: number | null;
+    signal: string | null;
+}
+export interface GuestTerminal {
+    readonly pid: number;
+    readonly started: Promise<number>;
+    readonly done: Promise<GuestTerminalExit>;
+    exited(): boolean;
+    activityRevision(): number;
+    onOutput(listener: (chunk: Buffer) => void): () => void;
+    write(data: Buffer | string): void;
+    resize(cols: number, rows: number): void;
+    inspectForeground(): Promise<{
+        processGroupId: number;
+        inputWaiting: boolean;
+    } | undefined>;
+    signalForeground(signal: string): Promise<number>;
+    terminate(): Promise<void>;
+}
+export declare function openGuestTerminal(binding: WorkspaceBinding, options: GuestTerminalOptions): GuestTerminal;

package/dist/guest-terminal.js

@@ -0,0 +1,196 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// One interactive guest-terminal stream. The harness's subprocess provider and
+// the browser terminal routes both build on this: the guest owns the pty and
+// reports started/stdout/exit plus foreground queries, so the terminal protocol
+// is spoken in exactly one place.
+import { remoteArgv } from "./guest-rpc.js";
+import { metadata } from "./workspace-binding.js";
+import { randomUUID } from "node:crypto";
+export function openGuestTerminal(binding, options) {
+    const call = binding.guest.terminal(metadata(binding.token));
+    const listeners = new Set();
+    const pending = new Map();
+    let pid = -1;
+    let exited = false;
+    let terminated = false;
+    let activity = 0;
+    let resolveStarted;
+    let rejectStarted;
+    const started = new Promise((resolveStartedPromise, rejectStartedPromise) => {
+        resolveStarted = resolveStartedPromise;
+        rejectStarted = rejectStartedPromise;
+    });
+    // A caller that never awaits startup must not crash on an unhandled rejection.
+    started.catch(() => { });
+    let resolveExit;
+    let rejectExit;
+    const done = new Promise((resolveExitPromise, rejectExitPromise) => {
+        resolveExit = resolveExitPromise;
+        rejectExit = rejectExitPromise;
+    });
+    done.catch(() => { });
+    const failPending = (error) => {
+        for (const waiter of pending.values())
+            waiter.reject(error);
+        pending.clear();
+    };
+    // Settle the stream exactly once, however it ends: an exit message, a stream
+    // error, or a stream that ends without one. Every path also releases pending
+    // foreground queries so a caller cannot hang on them.
+    const settle = (error, outcome) => {
+        if (exited)
+            return;
+        exited = true;
+        if (error !== undefined) {
+            rejectStarted(error);
+            rejectExit(error);
+            failPending(error);
+            return;
+        }
+        if (outcome !== undefined)
+            resolveExit(outcome);
+        failPending(new Error("terminal has exited"));
+    };
+    call.on("data", (message) => {
+        if (message.started) {
+            pid = Number(message.started.pid);
+            resolveStarted(pid);
+            return;
+        }
+        if (message.stdoutChunk) {
+            activity++;
+            const chunk = Buffer.from(message.stdoutChunk);
+            for (const listener of listeners)
+                listener(chunk);
+            return;
+        }
+        if (message.exit) {
+            settle(undefined, {
+                exitCode: message.exit.exitCode,
+                signal: message.exit.signaled ? message.exit.signal : null,
+            });
+            return;
+        }
+        if (message.foreground) {
+            activity++;
+            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) => {
+        settle(error instanceof Error ? error : new Error(String(error)));
+    });
+    call.on("end", () => {
+        settle(new Error("terminal stream ended before the process exited"));
+    });
+    const env = { ...(options.env ?? {}) };
+    if (options.terminalType !== undefined &&
+        options.terminalType !== "" &&
+        env.TERM === undefined) {
+        env.TERM = options.terminalType;
+    }
+    call.write({
+        start: {
+            argv: remoteArgv(options.argv),
+            cwd: options.cwd,
+            env,
+            rows: options.rows,
+            cols: options.cols,
+        },
+    });
+    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);
+            }
+        });
+    };
+    return {
+        get pid() {
+            return pid;
+        },
+        started,
+        done,
+        exited: () => exited,
+        activityRevision: () => activity,
+        onOutput: (listener) => {
+            listeners.add(listener);
+            return () => {
+                listeners.delete(listener);
+            };
+        },
+        write: (data) => {
+            if (exited)
+                throw new Error("terminal has exited");
+            activity++;
+            call.write({ stdinChunk: Buffer.from(data) });
+        },
+        resize: (cols, rows) => {
+            if (exited)
+                throw new Error("terminal has exited");
+            activity++;
+            call.write({ resize: { rows, cols } });
+        },
+        inspectForeground: async () => {
+            if (exited)
+                return undefined;
+            const response = await request((requestId) => ({
+                inspectRequestId: requestId,
+            }));
+            return response.found
+                ? {
+                    processGroupId: response.processGroupId,
+                    inputWaiting: response.inputWaiting,
+                }
+                : undefined;
+        },
+        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;
+        },
+        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.
+            }
+        },
+    };
+}

package/dist/images.test.js

@@ -4,7 +4,7 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { EXPECTED_TOOLS } from "./test-support.js";
-import { TOOLS, imageRemoveParameters, toolHandlers } from "./index.js";
+import { imageRemoveParameters, toolHandlers, TOOLS } from "./index.js";
 test("tool set covers the image and container surface", () => {
     assert.deepEqual(TOOLS.map((tool) => tool.name).sort(), [...EXPECTED_TOOLS].sort());
 });
@@ -12,7 +12,11 @@ test("image_build requires imageId, parent and packages", () => {
     const tool = TOOLS.find((entry) => entry.name === "image_build");
     assert.ok(tool, "image_build registered");
     assert.equal(tool.approval, true, "image_build must require approval");
-    assert.deepEqual(tool.parameters.required, ["imageId", "parent", "packages"]);
+    assert.deepEqual(tool.parameters.required, [
+        "imageId",
+        "parent",
+        "packages",
+    ]);
     assert.equal(tool.parameters.properties.imageId.description, "Image short name.");
     assert.ok(tool.parameters.properties.parent.description.includes("Short name of the parent image"), "parent must be documented as a short name");
 });
@@ -72,7 +76,10 @@ test("image_list returns image objects", async () => {
 });
 test("image_rebuild_all returns rebuilt and skipped arrays", async () => {
     const resolver = {
-        control: async () => ({ rebuilt: ["archlinux", "dev"], skipped: ["broken"] }),
+        control: async () => ({
+            rebuilt: ["archlinux", "dev"],
+            skipped: ["broken"],
+        }),
     };
     const out = await toolHandlers.image_rebuild_all(resolver, {}, {});
     assert.deepEqual(out, { rebuilt: ["archlinux", "dev"], skipped: ["broken"] });

package/dist/index.d.ts

@@ -1,22 +1,17 @@
+import { type Config } from "./settings-schema.js";
 export declare const name = "podman";
 export declare const inject: string[];
-export interface PluginConfig {
-    socketsRoot?: string;
-    defaultImage?: string;
-    projectsRoot?: string;
-    controlToken?: string;
-    imagePrefix?: string;
-}
-export declare function apply(ctx: any, config?: PluginConfig): void;
-export { PODMAN_OPS_APPROVAL_TOOLS, PODMAN_OPS_PRESET, READ_ONLY_TOOLS, SANDBOX_ESCALATION_REASON_PREFIX, approvalDecision, isSandboxEscalation, mountDestinationsReason, preExecutePolicy, summarizeArgs, } from "./approval.js";
+export declare function apply(ctx: any, config: Config): void;
+export { approvalDecision, isSandboxEscalation, mountDestinationsReason, PODMAN_OPS_APPROVAL_TOOLS, PODMAN_OPS_PRESET, preExecutePolicy, READ_ONLY_TOOLS, SANDBOX_ESCALATION_REASON_PREFIX, summarizeArgs, } from "./approval.js";
 export type { SessionFacts } from "./approval.js";
-export { READ_ONLY_GATED_TOOLS, REMOUNT_TOOL_NAME, createReadOnlyShellGate, } from "./read-only-shell.js";
-export { FilesystemProvider, createFilesystemProvider } from "./fs-provider.js";
-export { resolveGuestCwd, resolveGuestPath, remoteArgv, globCwd } from "./guest-rpc.js";
+export { createReadOnlyShellGate, READ_ONLY_GATED_TOOLS, REMOUNT_TOOL_NAME, } from "./read-only-shell.js";
+export { createFilesystemProvider, FilesystemProvider } from "./fs-provider.js";
+export { globCwd, remoteArgv, resolveGuestCwd, resolveGuestPath, } from "./guest-rpc.js";
 export { inferMountKind, projectMountDestinationReason, projectMountMirror, } from "./mount-input.js";
-export { HARNESS_SOURCE_SECTION, PODMAN_OPS_AGENT_CORDIS_YML, PODMAN_OPS_PRESET_YML, ensurePodmanOpsPreset, homePresetsRoot, podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
-export { publicContainer, publicDaemon, publicImage, publicMount } from "./public.js";
-export { OutputReader, SubprocessProvider, createSubprocessProvider, outputReader, } from "./subprocess.js";
+export { HARNESS_SOURCE_SECTION, podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
+export { Config } from "./settings-schema.js";
+export { publicContainer, publicDaemon, publicImage, publicMount, } from "./public.js";
+export { createSubprocessProvider, OutputReader, outputReader, SubprocessProvider, } from "./subprocess.js";
 export { toolHandlers } from "./tool-handlers.js";
-export { TOOLS, ToolDefinition, containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, defineTool, envParam, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, toolOutput, volumeCreateParameters, volumeListParameters, volumeRemoveParameters, } from "./tool-schemas.js";
+export { containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, defineTool, envParam, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, ToolDefinition, toolOutput, TOOLS, volumeCreateParameters, volumeListParameters, volumeRemoveParameters, } from "./tool-schemas.js";
 export { toolCallView, toolResultView } from "./tool-views.js";

package/dist/index.js

@@ -1,32 +1,27 @@
 // SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
 //
 // SPDX-License-Identifier: MIT
-import { isSandboxEscalation, preExecutePolicy } from "./approval.js";
+import { isSandboxEscalation, preExecutePolicy, } from "./approval.js";
 import { resolveReasonLocale } from "./approval-reasons.js";
 import { createFilesystemProvider } from "./fs-provider.js";
 import { createSpillStore } from "./spill-store.js";
-import { ensurePodmanOpsPreset, podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
+import { podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
 import { createSubprocessProvider } from "./subprocess.js";
-import { createReadOnlyShellGate, REMOUNT_TOOL_NAME } from "./read-only-shell.js";
+import { createReadOnlyShellGate, REMOUNT_TOOL_NAME, } from "./read-only-shell.js";
 import { toolHandlers } from "./tool-handlers.js";
-import { TOOLS, TOOL_DESCRIPTIONS, defineTool, toolOutput } from "./tool-schemas.js";
+import { defineTool, TOOL_DESCRIPTIONS, toolOutput, TOOLS, } from "./tool-schemas.js";
 import { toolCallView, toolResultView } from "./tool-views.js";
-import { installContainerPreferences } from "./preferences.js";
 import { registerCardRoute } from "./card-route.js";
-import { WorkspaceResolver, normalizeToolError } from "./workspace-binding.js";
-function withTrailingSlash(value) {
-    return value.endsWith("/") ? value : `${value}/`;
-}
+import { registerTerminalRoutes } from "./terminal-route.js";
+import { TerminalSessions } from "./terminal-sessions.js";
+import { normalizeToolError, WorkspaceResolver } from "./workspace-binding.js";
 export const name = "podman";
 export const inject = ["tools", "workspaceRegistry"];
-export function apply(ctx, config = {}) {
+export function apply(ctx, config) {
     // Approval text follows the session language: the browser client records its
-    // active locale in the plugin namespace, with the durable user preference as
-    // the fallback. Without a settings provider everything renders in English.
-    let readLocale = () => "en";
-    ctx.inject(["settings"], (settingsCtx) => {
-        readLocale = () => resolveReasonLocale(settingsCtx.settings);
-    });
+    // active locale in the plugin's own volatile `uiLocale` preference, so the
+    // value is always read live and an unset one renders in English.
+    const readLocale = () => resolveReasonLocale(config.uiLocale.get());
     // The session's permission knobs live in the harness's own services: the
     // sandbox policy resolves the effective mode (approved override, last logged
     // mode, then the deployment default), the approval service reports the logged
@@ -76,19 +71,20 @@ export function apply(ctx, config = {}) {
     // listener is prepended so it runs before the bridge that forwards approvals
     // to the browser, and it delegates everything else.
     ctx.on("approval/request", (request, next) => isSandboxEscalation(request) ? Promise.resolve("allowed-once") : next(), { prepend: true });
-    ensurePodmanOpsPreset(ctx);
-    const imagePrefix = withTrailingSlash(config.imagePrefix ?? process.env.DSH_PODMAN_IMAGE_PREFIX ?? "localhost/dsh-podman/");
-    const resolver = new WorkspaceResolver({
-        socketsRoot: config.socketsRoot ??
-            process.env.DSH_PODMAN_SOCKETS_ROOT ??
-            "/run/dsh-podman",
-        defaultImage: config.defaultImage ?? "archlinux",
-        projectsRoot: config.projectsRoot ??
-            process.env.DSH_PODMAN_PROJECTS_ROOT ??
-            "/projects",
-        controlToken: config.controlToken ?? process.env.DSH_PODMAN_ORCHESTRATOR_TOKEN ?? "",
-    }, ctx.workspaceRegistry);
+    const resolver = new WorkspaceResolver(
+    // A reader, not a snapshot: every preference is a volatile config field an
+    // edit commits in place, so the resolver observes changes without a reload.
+    () => ({
+        // Both roots are env-only, so the plugin and the orchestrator always
+        // resolve the same paths.
+        socketsRoot: process.env.DSH_PODMAN_SOCKETS_ROOT ?? "/run/dsh-podman",
+        defaultImage: config.defaultImage.get() || "archlinux",
+        projectsRoot: process.env.DSH_PODMAN_PROJECTS_ROOT ?? "/projects",
+        controlToken: process.env.DSH_PODMAN_ORCHESTRATOR_TOKEN ?? "",
+        containerEnv: config.containerEnv.get(),
+    }), ctx.workspaceRegistry);
     ctx.provide("workspaceResolver", resolver);
+    ctx.effect(() => () => resolver.dispose(), "podman: resolver cleanup");
     const subprocess = createSubprocessProvider(resolver);
     ctx.provide("subprocess", subprocess);
     ctx.effect(() => () => subprocess.dispose(), "podman: subprocess cleanup");
@@ -102,8 +98,17 @@ export function apply(ctx, config = {}) {
         promptCtx.on("system-prompt/assemble", async (_assembly, _context, next) => withoutHarnessSourceSection(await next()), { global: true, prepend: true });
     });
     registerTools(ctx, resolver);
-    installContainerPreferences(ctx, resolver);
-    registerCardRoute(ctx, resolver, ctx.workspaceRegistry);
+    // The plugin ships its own configuration card, so the host must not
+    // auto-generate a settings page for the preferences namespace.
+    ctx.inject(["settings"], (child) => {
+        child.effect(() => child.settings.configure({ auto: false }, ctx.fiber), "podman: settings presentation");
+    });
+    registerCardRoute(ctx, resolver, ctx.workspaceRegistry, readLocale);
+    // The Podman terminal tab talks to guest ptys through its own routes; the
+    // registry keeps shells alive while the browser is away.
+    const terminalSessions = new TerminalSessions({ resolver });
+    ctx.effect(() => () => terminalSessions.dispose(), "podman: terminal sessions cleanup");
+    registerTerminalRoutes(ctx, resolver, terminalSessions, ctx.workspaceRegistry);
 }
 function registerTools(ctx, resolver) {
     for (const tool of TOOLS) {
@@ -127,14 +132,15 @@ function registerTools(ctx, resolver) {
         }));
     }
 }
-export { PODMAN_OPS_APPROVAL_TOOLS, PODMAN_OPS_PRESET, READ_ONLY_TOOLS, SANDBOX_ESCALATION_REASON_PREFIX, approvalDecision, isSandboxEscalation, mountDestinationsReason, preExecutePolicy, summarizeArgs, } from "./approval.js";
-export { READ_ONLY_GATED_TOOLS, REMOUNT_TOOL_NAME, createReadOnlyShellGate, } from "./read-only-shell.js";
+export { approvalDecision, isSandboxEscalation, mountDestinationsReason, PODMAN_OPS_APPROVAL_TOOLS, PODMAN_OPS_PRESET, preExecutePolicy, READ_ONLY_TOOLS, SANDBOX_ESCALATION_REASON_PREFIX, summarizeArgs, } from "./approval.js";
+export { createReadOnlyShellGate, READ_ONLY_GATED_TOOLS, REMOUNT_TOOL_NAME, } from "./read-only-shell.js";
 export { createFilesystemProvider } from "./fs-provider.js";
-export { resolveGuestCwd, resolveGuestPath, remoteArgv, globCwd } from "./guest-rpc.js";
+export { globCwd, remoteArgv, resolveGuestCwd, resolveGuestPath, } from "./guest-rpc.js";
 export { inferMountKind, projectMountDestinationReason, projectMountMirror, } from "./mount-input.js";
-export { HARNESS_SOURCE_SECTION, PODMAN_OPS_AGENT_CORDIS_YML, PODMAN_OPS_PRESET_YML, ensurePodmanOpsPreset, homePresetsRoot, podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
-export { publicContainer, publicDaemon, publicImage, publicMount } from "./public.js";
+export { HARNESS_SOURCE_SECTION, podmanRuntimeSection, withoutHarnessSourceSection, } from "./prompts.js";
+export { Config } from "./settings-schema.js";
+export { publicContainer, publicDaemon, publicImage, publicMount, } from "./public.js";
 export { createSubprocessProvider, outputReader, } from "./subprocess.js";
 export { toolHandlers } from "./tool-handlers.js";
-export { TOOLS, containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, defineTool, envParam, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, toolOutput, volumeCreateParameters, volumeListParameters, volumeRemoveParameters, } from "./tool-schemas.js";
+export { containerBashParameters, containerEditParameters, containerExecParameters, containerGlobParameters, containerGrepParameters, containerListParameters, containerMountAddParameters, containerMountListParameters, containerMountRemoveParameters, containerReadParameters, containerRecreateParameters, containerRemoveParameters, containerSecretAddParameters, containerSecretRemoveParameters, containerStartParameters, containerWriteParameters, daemonListParameters, daemonLogsParameters, daemonRestartParameters, daemonStartParameters, daemonStopParameters, defineTool, envParam, imageBuildParameters, imageGetParameters, imageListParameters, imageRebuildAllParameters, imageRebuildParameters, imageRemoveParameters, secretCreateParameters, secretListParameters, secretRemoveParameters, toolOutput, TOOLS, volumeCreateParameters, volumeListParameters, volumeRemoveParameters, } from "./tool-schemas.js";
 export { toolCallView, toolResultView } from "./tool-views.js";

package/dist/locales.test.d.ts

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