@exagone313/dsh-podman 0.2.0-rc.2

package/dist/test-support.js

@@ -0,0 +1,437 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import { EventEmitter } from "node:events";
+import { createFilesystemProvider } from "./index.js";
+// WORKSPACE_ID is a valid workspace id: slugs are UUIDs, and the pod/container
+// names are derived from one.
+export const WORKSPACE_ID = "2c573001-4171-4900-904b-12a5cc02737a";
+export class FakeTerminalCall extends EventEmitter {
+    stdinChunks = [];
+    write(message) {
+        if (message.start) {
+            queueMicrotask(() => this.emit("data", { started: { pid: 42 } }));
+            return;
+        }
+        if (message.stdinChunk) {
+            this.stdinChunks.push(Buffer.from(message.stdinChunk));
+            return;
+        }
+        if (message.inspectRequestId !== undefined) {
+            const requestId = message.inspectRequestId;
+            queueMicrotask(() => this.emit("data", {
+                foreground: { requestId, found: true, processGroupId: 7, inputWaiting: true },
+            }));
+            return;
+        }
+        if (message.signal) {
+            const requestId = message.signal.requestId;
+            queueMicrotask(() => this.emit("data", {
+                signalled: { requestId, found: true, processGroupId: 7 },
+            }));
+        }
+    }
+    end() { }
+    cancel() { }
+    emitStdout(data) {
+        this.emit("data", { stdoutChunk: data });
+    }
+    emitExit(exitCode = 0, signaled = false) {
+        this.emit("data", { exit: { exitCode, signaled, signal: "" } });
+        this.emit("end");
+    }
+}
+export const fakeTerminalResolver = (fake) => ({
+    resolveForPath: async () => ({
+        guest: { terminal: () => fake },
+        token: "t",
+    }),
+});
+export const stubResolver = {
+    resolve: async () => ({ kind: "binding" }),
+    resolveForPath: async () => ({ kind: "binding" }),
+};
+export const EXPECTED_TOOLS = [
+    "image_list",
+    "image_get",
+    "image_build",
+    "image_rebuild",
+    "image_rebuild_all",
+    "image_remove",
+    "container_list",
+    "container_start",
+    "container_recreate",
+    "container_remove",
+    "container_bash",
+    "container_exec",
+    "container_read",
+    "container_write",
+    "container_edit",
+    "container_glob",
+    "container_grep",
+    "container_mount_list",
+    "container_mount_add",
+    "container_mount_remove",
+    "container_mount_update",
+    "container_path_set",
+    "container_path_add",
+    "container_path_remove",
+    "volume_list",
+    "volume_create",
+    "volume_remove",
+    "secret_list",
+    "secret_create",
+    "secret_remove",
+    "container_secret_add",
+    "container_secret_remove",
+    "daemon_start",
+    "daemon_list",
+    "daemon_stop",
+    "daemon_restart",
+    "daemon_logs",
+];
+export const testReadSession = (session) => session?.facts ?? {};
+export const sessionExec = (name, facts = { mode: "read-only" }) => ({
+    name,
+    agent: { session: { facts } },
+});
+export const presetExec = (name, preset, args, facts = {}) => ({
+    name,
+    arguments: args,
+    agent: { session: { header: { agentPreset: preset }, facts: { ...facts, preset } } },
+});
+export const MOUNT_TOOLS = [
+    "container_mount_list",
+    "container_mount_add",
+    "container_mount_remove",
+    "container_mount_update",
+];
+export const VOLUME_TOOLS = ["volume_list", "volume_create", "volume_remove"];
+export const SECRET_TOOLS = [
+    "secret_list",
+    "secret_create",
+    "secret_remove",
+    "container_secret_add",
+    "container_secret_remove",
+];
+export function mountRequestRecorder() {
+    const requests = [];
+    const resolver = {
+        registry: {
+            resolveByPath: async () => ({ id: WORKSPACE_ID }),
+        },
+        getConfig: () => ({ projectsRoot: "/projects" }),
+        async control(method, request) {
+            requests.push([method, request]);
+            return {};
+        },
+    };
+    return { requests, resolver };
+}
+export const MOUNT_EXEC = { agent: { session: { header: { cwd: "/proj" } } } };
+export const DAEMON_TOOLS = [
+    "daemon_start",
+    "daemon_list",
+    "daemon_stop",
+    "daemon_restart",
+    "daemon_logs",
+];
+export const SECRET_BEARING_CONTAINER = {
+    workspaceSlug: WORKSPACE_ID,
+    containerName: "default",
+    imageId: "img-1",
+    status: "running",
+    createdAt: "2026-01-01T00:00:00Z",
+    podmanName: `dsh-podman-${WORKSPACE_ID}-default`,
+    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" },
+    ],
+    env: { PATH: "/bin", DB_PASSWORD: "hunter2" },
+    secretEnv: { DB_PASS: "db-pass" },
+};
+export function secretBearingResolver() {
+    return {
+        registry: {
+            resolveByPath: async () => ({ id: WORKSPACE_ID }),
+        },
+        getConfig: () => ({ projectsRoot: "/projects" }),
+        control: async () => SECRET_BEARING_CONTAINER,
+    };
+}
+// Stubs the guest agent's streaming ReadFile/WriteFile calls, recording the
+// paths the tools ask for.
+export function guestFileRecorder(content = "hello", exists = true) {
+    const reads = [];
+    const writes = [];
+    const mkdirs = [];
+    const guest = {
+        readFile: (request) => {
+            reads.push(request.path);
+            return {
+                async *[Symbol.asyncIterator]() {
+                    yield { data: Buffer.from(content) };
+                },
+                cancel() { },
+            };
+        },
+        mkdir: (request, _metadata, callback) => {
+            mkdirs.push(request.path);
+            callback(null, {});
+            return { cancel() { } };
+        },
+        stat: (_request, _metadata, callback) => {
+            callback(null, exists
+                ? {
+                    exists: true,
+                    isDir: false,
+                    size: Buffer.byteLength(content),
+                    modifiedAt: "1",
+                    mode: 0o644,
+                }
+                : { exists: false });
+            return { cancel() { } };
+        },
+        writeFile: (_metadata, _options, callback) => {
+            let path = "";
+            let body = "";
+            return {
+                write(message) {
+                    if (message.start !== undefined)
+                        path = message.start.path;
+                    if (message.dataChunk !== undefined)
+                        body += String(message.dataChunk);
+                },
+                end() {
+                    writes.push({ path, content: body });
+                    callback(null, { bytesWritten: body.length });
+                },
+            };
+        },
+    };
+    const binding = { guest, token: "t", socket: "/run/x.sock" };
+    const resolver = {
+        resolve: async () => binding,
+        containerBinding: async () => binding,
+        resolveForPath: async () => binding,
+    };
+    return { reads, writes, mkdirs, resolver };
+}
+// fakeToolContext is the minimal cordis context the container file tools need:
+// the plugin's real filesystem provider over the given resolver, the fs
+// observation waterfalls stubbed to "no intent" (an unconditional write), and
+// an `emit` that records the `fs/observed` events the tools report.
+export function fakeToolContext(resolver) {
+    const observed = [];
+    return {
+        fs: createFilesystemProvider(resolver),
+        observed,
+        async waterfall(_name, _target, _actor, next) {
+            return await next();
+        },
+        emit(event, target, observation) {
+            if (event === "fs/observed")
+                observed.push({ target, observation });
+        },
+    };
+}
+// Stubs the guest agent's streaming Exec call, recording the start message.
+export function guestExecRecorder(defaultCwd, stdout) {
+    const starts = [];
+    const guest = {
+        exec: () => {
+            const handlers = {};
+            return {
+                on(event, handler) {
+                    (handlers[event] ??= []).push(handler);
+                },
+                write(message) {
+                    starts.push({
+                        argv: message.start.argv,
+                        cwd: message.start.cwd,
+                        env: message.start.env,
+                        ...(message.start.uid !== undefined
+                            ? { uid: message.start.uid.value }
+                            : {}),
+                        ...(message.start.gid !== undefined
+                            ? { gid: message.start.gid.value }
+                            : {}),
+                        ...(message.start.groups !== undefined
+                            ? { groups: message.start.groups }
+                            : {}),
+                    });
+                },
+                end() {
+                    for (const handler of handlers.data ?? []) {
+                        if (stdout !== undefined)
+                            handler({ stdoutChunk: Buffer.from(stdout) });
+                        handler({ exit: { exitCode: 0, signaled: false } });
+                    }
+                },
+            };
+        },
+    };
+    const binding = {
+        guest,
+        token: "t",
+        socket: "/run/x.sock",
+        ...(defaultCwd === undefined ? {} : { defaultCwd }),
+    };
+    const resolver = {
+        resolve: async () => binding,
+        containerBinding: async () => binding,
+    };
+    return { starts, resolver };
+}
+// A resolver for the container_path_* tools: the guest stubs GetPaths/SetPaths
+// (the agent's live list) and control records the setContainerPaths call.
+export function pathRequestRecorder(options = {}) {
+    const controlCalls = [];
+    const setCalls = [];
+    const defaultPath = options.defaultPath ?? "/usr/bin";
+    let paths = options.paths ?? [];
+    const guest = {
+        getPaths: (_request, _metadata, callback) => callback(null, { paths, defaultPath }),
+        setPaths: (request, _metadata, callback) => {
+            setCalls.push(request.paths);
+            paths = request.paths;
+            callback(null, { paths, defaultPath });
+        },
+    };
+    const binding = { guest, token: "t", socket: "/run/x.sock" };
+    const resolver = {
+        registry: { resolveByPath: async () => ({ id: WORKSPACE_ID }) },
+        getConfig: () => ({ projectsRoot: "/projects" }),
+        resolve: async () => binding,
+        containerBinding: async () => binding,
+        async control(method, request) {
+            controlCalls.push([method, request]);
+            return { paths: request.paths ?? [] };
+        },
+    };
+    return { controlCalls, setCalls, resolver };
+}
+// A fake guest whose readFile honors offset/length, so the provider's byte
+// windowing and text decoding can be exercised without a container.
+export function fakeGuest(source) {
+    const requests = [];
+    return {
+        requests,
+        guest: {
+            readFile: (request) => {
+                requests.push(request);
+                return {
+                    async *[Symbol.asyncIterator]() {
+                        const offset = Number(request.offset ?? 0);
+                        const length = Number(request.length ?? 0);
+                        const slice = length > 0
+                            ? source.subarray(offset, offset + length)
+                            : source.subarray(offset);
+                        yield { data: slice };
+                    },
+                };
+            },
+        },
+    };
+}
+export function providerFor(guest) {
+    return createFilesystemProvider({
+        resolveForPath: async () => ({ guest, token: "t" }),
+    });
+}
+// A fake guest for the text/byte provider methods: a stat result, a one-chunk
+// readFile, and a no-op writeFile.
+export function editGuest(stat, content = Buffer.alloc(0)) {
+    const writes = [];
+    return {
+        writes,
+        guest: {
+            stat: (_request, _metadata, callback) => callback(null, {
+                exists: true,
+                isDir: false,
+                isSymlink: false,
+                size: String(content.length),
+                mode: "-rw-r--r--",
+                modifiedAt: "t",
+                ...stat,
+            }),
+            readFile: () => ({
+                async *[Symbol.asyncIterator]() {
+                    yield { data: content };
+                },
+            }),
+            writeFile: (_metadata, _options, callback) => {
+                const call = {
+                    write(message) {
+                        if (message?.dataChunk)
+                            writes.push(Buffer.from(message.dataChunk));
+                    },
+                    end() { },
+                };
+                callback(null, { bytesWritten: 0 });
+                return call;
+            },
+        },
+        token: "t",
+    };
+}
+export function editProvider(binding) {
+    return createFilesystemProvider({
+        resolveForPath: async () => binding,
+    });
+}
+// 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 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 },
+                            });
+                        }
+                    }
+                },
+            };
+        },
+        signal: (request, _metadata, callback) => {
+            signals.push(request);
+            callback(null, {});
+        },
+        delete: (request, _metadata, callback) => {
+            deletes.push(request);
+            callback(null, {});
+        },
+    };
+    return {
+        signals,
+        starts,
+        deletes,
+        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 } },
+    graceMs: 50,
+    ...overrides,
+});

package/dist/tool-defs.d.ts

@@ -0,0 +1,26 @@
+export declare function defineTool<T>(definition: T): T;
+export declare const toolOutput: {
+    schema: {
+        type: string;
+    };
+    render: (_args: unknown, value: string) => {
+        type: string;
+        text: string;
+    }[];
+};
+export interface ToolDefinition {
+    name: string;
+    parameters: {
+        type: string;
+        properties: Record<string, any>;
+        required: readonly string[];
+    };
+    approval?: boolean;
+    approvalWhen?: (args: Record<string, unknown>) => boolean;
+}
+export declare const TOOLS: ToolDefinition[];
+export declare const TOOL_DESCRIPTIONS: Record<string, string>;
+export declare const TOOL_UI: Record<string, {
+    title: string;
+    kind: string;
+}>;

package/dist/tool-defs.js

@@ -0,0 +1,188 @@
+// 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";
+export function defineTool(definition) {
+    return definition;
+}
+export const toolOutput = {
+    schema: { type: "string" },
+    render: (_args, value) => [{ type: "text", text: value }],
+};
+export const TOOLS = [
+    { name: "image_list", parameters: imageListParameters },
+    { name: "image_get", parameters: imageGetParameters },
+    {
+        name: "image_build",
+        parameters: imageBuildParameters,
+        approval: true,
+    },
+    { name: "image_rebuild", parameters: imageRebuildParameters, approval: true },
+    {
+        name: "image_rebuild_all",
+        parameters: imageRebuildAllParameters,
+        approval: true,
+    },
+    { name: "image_remove", parameters: imageRemoveParameters, approval: true },
+    { name: "container_list", parameters: containerListParameters },
+    {
+        name: "container_start",
+        parameters: containerStartParameters,
+        approvalWhen: (args) => Array.isArray(args.mounts) && args.mounts.length > 0,
+    },
+    {
+        name: "container_recreate",
+        parameters: containerRecreateParameters,
+        approval: true,
+    },
+    { name: "container_remove", parameters: containerRemoveParameters, approval: true },
+    { name: "container_bash", parameters: containerBashParameters },
+    { name: "container_exec", parameters: containerExecParameters },
+    { name: "container_read", parameters: containerReadParameters },
+    { name: "container_write", parameters: containerWriteParameters },
+    { name: "container_edit", parameters: containerEditParameters },
+    { name: "container_glob", parameters: containerGlobParameters },
+    { name: "container_grep", parameters: containerGrepParameters },
+    {
+        name: "container_mount_list",
+        parameters: containerMountListParameters,
+    },
+    {
+        name: "container_mount_add",
+        parameters: containerMountAddParameters,
+        approval: true,
+    },
+    {
+        name: "container_mount_remove",
+        parameters: containerMountRemoveParameters,
+        approval: true,
+    },
+    {
+        name: "container_mount_update",
+        parameters: containerMountUpdateParameters,
+        approval: true,
+    },
+    {
+        name: "container_path_set",
+        parameters: containerPathSetParameters,
+        approval: true,
+    },
+    {
+        name: "container_path_add",
+        parameters: containerPathAddParameters,
+        approval: true,
+    },
+    {
+        name: "container_path_remove",
+        parameters: containerPathRemoveParameters,
+        approval: true,
+    },
+    { name: "volume_list", parameters: volumeListParameters },
+    { name: "volume_create", parameters: volumeCreateParameters },
+    { name: "volume_remove", parameters: volumeRemoveParameters, approval: true },
+    { name: "secret_list", parameters: secretListParameters },
+    {
+        name: "secret_create",
+        parameters: secretCreateParameters,
+    },
+    {
+        name: "secret_remove",
+        parameters: secretRemoveParameters,
+        approval: true,
+    },
+    {
+        name: "container_secret_add",
+        parameters: containerSecretAddParameters,
+        approval: true,
+    },
+    {
+        name: "container_secret_remove",
+        parameters: containerSecretRemoveParameters,
+        approval: true,
+    },
+    { name: "daemon_start", parameters: daemonStartParameters },
+    { name: "daemon_list", parameters: daemonListParameters },
+    { name: "daemon_stop", parameters: daemonStopParameters },
+    { name: "daemon_restart", parameters: daemonRestartParameters },
+    { name: "daemon_logs", parameters: daemonLogsParameters },
+];
+export const TOOL_DESCRIPTIONS = {
+    image_list: "List the images of the current workspace by short name, base images first, then custom images. Base images are managed from the settings.",
+    image_get: "Get details about a specific image by its short name.",
+    image_build: "Build a new custom image from a parent image by short name (a base like archlinux/ubuntu/alpine, or an existing custom image) and a set of packages. Base images themselves are managed from the settings. Requires approval: building installs packages system-wide into a container image.",
+    image_rebuild: "Rebuild an existing custom image by short name. Base images are rebuilt from the settings. Requires approval: rebuilding replaces the current image content.",
+    image_rebuild_all: "Rebuild every stored image in dependency order (base first), skipping any image whose rebuild fails and its dependents. Requires approval: rebuilding replaces the images' contents.",
+    image_remove: "Remove a built custom image by short name. Base images are managed from the settings. Requires approval: removing deletes the image so containers using it must be recreated from another image.",
+    container_list: "List the containers of the current workspace, including the default container that is started on demand.",
+    container_start: "Start a container in the current workspace. Named containers are created with exactly the mounts you pass — the project directory is not mounted automatically. The default container always keeps its workspace project mount. Pass paths to replace the container's PATH additions.",
+    container_recreate: "Recreate a container in the current workspace, keeping its current image when no image is given, optionally with new project mounts. Pass paths to replace the container's PATH additions. Requires approval: recreating replaces the running container.",
+    container_remove: "Remove a container from the current workspace.",
+    container_bash: "Run a shell command inside a container of the current workspace. Defaults to the session working directory when it is mounted; pass workdir to override.",
+    container_exec: "Run a program inside a container of the current workspace. Defaults to the session working directory when it is mounted; pass cwd to override.",
+    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_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.",
+    container_mount_remove: "Remove a mount from a container in the current workspace. Identify it by kind plus its own handle: project for a project mount, volume for a named volume, secret for a secret, and destination for tmpfs. A handle that matches more than one mount is rejected, so pass destination as well when a volume or secret is mounted more than once; copy the exact values from container_mount_list. Recreates the container, terminating its running processes; bind-mounted volume data persists. Requires approval: removing a mount changes the container filesystem view.",
+    container_mount_update: "Change the mode of an existing project or volume mount in the current workspace (read_only or read_write). Identify it by kind plus its own handle, exactly like container_mount_remove; a handle that matches more than one mount is rejected. The default container's workspace project mount can be remounted read-only. Recreates the container, terminating its running processes; bind-mounted volume data persists. Requires approval: changing a mount's mode changes the container filesystem view.",
+    container_path_set: "Replace the directories the container prepends to PATH for every command it runs, highest priority first. Applied immediately to future shell, exec, terminal, and daemon runs without recreating the container; already-running daemons keep their old PATH. A recreated container restores the list. Requires approval: changing PATH changes which binaries run.",
+    container_path_add: "Prepend one directory to the container's PATH additions, moving it to the front when it is already there. Applied immediately without recreating the container; already-running daemons keep their old PATH. Requires approval: changing PATH changes which binaries run.",
+    container_path_remove: "Remove one directory from the container's PATH additions. A directory that is only part of the container's default PATH cannot be removed. Applied immediately without recreating the container; already-running daemons keep their old PATH. Requires approval: changing PATH changes which binaries run.",
+    volume_list: "List the named volumes available to the current workspace.",
+    volume_create: "Create a named volume in the current workspace.",
+    volume_remove: "Remove a named volume from the current workspace. Refused while a container still mounts it; detach the mount first.",
+    secret_list: "List the named secrets available to the current workspace (values are never exposed).",
+    secret_create: "Create a secret with an orchestrator-generated random value (the value is never exposed).",
+    secret_remove: "Remove a named secret from the current workspace. Refused while a container mounts it or attaches it as an environment variable; detach it first. Requires approval: removing deletes the secret.",
+    container_secret_add: "Inject a named secret into a container as an environment variable. Recreates the container, terminating its running processes; bind-mounted volume data persists. Requires approval: exposing a secret to a container changes what it can read.",
+    container_secret_remove: "Stop injecting a named secret into a container environment variable. Recreates the container, terminating its running processes; bind-mounted volume data persists. Requires approval: removing a secret exposure changes what the container can read.",
+    daemon_start: "Start a daemon inside a container of the current workspace. Optionally run it as a specific uid/gid (with optional supplementary groups). The daemon inherits the container's environment by default; pass inheritEnv=false to give it only PATH, HOME, and env. Defaults to the session working directory when it is mounted; pass cwd to override. An existing daemon with the same name is stopped and replaced.",
+    daemon_list: "List the daemons running inside a container of the current workspace. Daemons live in the container's guest agent and do not survive a container recreate.",
+    daemon_stop: "Stop a daemon inside a container of the current workspace.",
+    daemon_restart: "Restart a daemon inside a container of the current workspace.",
+    daemon_logs: "Read the captured logs of a daemon inside a container of the current workspace.",
+};
+// UI title and icon category per tool, used by the host presenters so a UI can
+// label a call meaningfully instead of showing the raw tool name.
+export const TOOL_UI = {
+    image_list: { title: "List images", kind: "search" },
+    image_get: { title: "Inspect image", kind: "read" },
+    image_build: { title: "Build image", kind: "execute" },
+    image_rebuild: { title: "Rebuild image", kind: "execute" },
+    image_rebuild_all: { title: "Rebuild all images", kind: "execute" },
+    image_remove: { title: "Remove image", kind: "delete" },
+    container_list: { title: "List containers", kind: "search" },
+    container_start: { title: "Start container", kind: "execute" },
+    container_recreate: { title: "Recreate container", kind: "execute" },
+    container_remove: { title: "Remove container", kind: "delete" },
+    container_bash: { title: "Container bash", kind: "execute" },
+    container_exec: { title: "Container exec", kind: "execute" },
+    container_read: { title: "Container read", kind: "read" },
+    container_write: { title: "Container write", kind: "edit" },
+    container_edit: { title: "Container edit", kind: "edit" },
+    container_glob: { title: "Container glob", kind: "search" },
+    container_grep: { title: "Container grep", kind: "search" },
+    container_mount_list: { title: "List mounts", kind: "read" },
+    container_mount_add: { title: "Add mount", kind: "edit" },
+    container_mount_remove: { title: "Remove mount", kind: "delete" },
+    container_mount_update: { title: "Change mount mode", kind: "edit" },
+    container_path_set: { title: "Set PATH additions", kind: "edit" },
+    container_path_add: { title: "Add PATH entry", kind: "edit" },
+    container_path_remove: { title: "Remove PATH entry", kind: "delete" },
+    volume_list: { title: "List volumes", kind: "search" },
+    volume_create: { title: "Create volume", kind: "execute" },
+    volume_remove: { title: "Remove volume", kind: "delete" },
+    secret_list: { title: "List secrets", kind: "search" },
+    secret_create: { title: "Create secret", kind: "execute" },
+    secret_remove: { title: "Remove secret", kind: "delete" },
+    container_secret_add: { title: "Attach secret", kind: "edit" },
+    container_secret_remove: { title: "Detach secret", kind: "delete" },
+    daemon_start: { title: "Start daemon", kind: "execute" },
+    daemon_list: { title: "List daemons", kind: "read" },
+    daemon_stop: { title: "Stop daemon", kind: "delete" },
+    daemon_restart: { title: "Restart daemon", kind: "execute" },
+    daemon_logs: { title: "Daemon logs", kind: "read" },
+};

package/dist/tool-handlers.d.ts

@@ -0,0 +1,2 @@
+import { WorkspaceResolver } from "./workspace-binding.js";
+export declare const toolHandlers: Record<string, (resolver: WorkspaceResolver, input: any, exec: any, ctx?: any) => Promise<unknown>>;