@exagone313/dsh-podman 0.2.0-rc.2

package/dist/settings-mounts.test.js

@@ -0,0 +1,467 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import { test } from "node:test";
+import { strict as assert } from "node:assert";
+import { baseValue, fakeContext, fakeScope, installedMountScope, mountCommand, } from "./card-test-support.js";
+import { installCardCommandDriver } from "./card-test-support.js";
+test("create command drives createWorkspace with mounts and image", async () => {
+    const scope = fakeScope(baseValue());
+    const calls = [];
+    const resolver = {
+        getConfig: () => ({}),
+        setConfig: () => { },
+        async control(method, request) {
+            calls.push([method, request]);
+            if (method === "listContainers")
+                return { containers: [] };
+            if (method === "listImages")
+                return { images: [] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            return {};
+        },
+    };
+    await installCardCommandDriver(fakeContext(scope), resolver);
+    await scope.update({
+        command: {
+            op: "create",
+            workspace: "w1",
+            projectName: "team",
+            image: "img1",
+            at: 1,
+            mounts: [{ kind: "project", project: "team", mode: "read_write", destination: "", volume: "", secret: "" }],
+            env: {},
+            container: "",
+            secretEnvMap: {},
+            mount: null,
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    const createCall = calls.find(([method]) => method === "createWorkspace");
+    assert.deepEqual(createCall?.[1], {
+        workspaceSlug: "w1",
+        projectName: "team",
+        imageId: "img1",
+        mounts: [{ projectName: "team", kind: "MOUNT_KIND_PROJECT", mode: "MOUNT_MODE_READ_WRITE" }],
+    });
+    assert.equal(scope.value.command, null);
+});
+test("container_mount_add command drives addContainerMount for each kind", async () => {
+    const scope = fakeScope(baseValue());
+    const calls = [];
+    const resolver = {
+        getConfig: () => ({}),
+        setConfig: () => { },
+        async control(method, request) {
+            calls.push([method, request]);
+            if (method === "listContainers")
+                return { containers: [] };
+            if (method === "listImages")
+                return { images: [] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            return {};
+        },
+    };
+    await installCardCommandDriver(fakeContext(scope), resolver);
+    await scope.update({
+        command: {
+            op: "container_mount_add",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 1,
+            mount: {
+                kind: "project",
+                project: "team/src",
+                destination: "/workspace/team",
+                mode: "read_only",
+                volume: "",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_add",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 2,
+            mount: {
+                kind: "volume",
+                project: "",
+                destination: "/data",
+                mode: "read_write",
+                volume: "valkey-data",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_add",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 3,
+            mount: {
+                kind: "tmpfs",
+                project: "",
+                destination: "/dev/shm",
+                mode: "read_write",
+                volume: "",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_add",
+            workspace: "w1",
+            container: "",
+            image: "",
+            at: 4,
+            mount: {
+                kind: "secret",
+                project: "",
+                destination: "/run/secrets/tls",
+                mode: "read_write",
+                volume: "",
+                secret: "valkey-tls",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    const addCalls = calls.filter(([method]) => method === "addContainerMount");
+    assert.deepEqual(addCalls.map(([, request]) => request), [
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_PROJECT",
+            project: "team/src",
+            mode: "MOUNT_MODE_READ_ONLY",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_VOLUME",
+            volume: "valkey-data",
+            destination: "/data",
+            mode: "MOUNT_MODE_READ_WRITE",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_TMPFS",
+            destination: "/dev/shm",
+            mode: "MOUNT_MODE_READ_WRITE",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "default",
+            kind: "MOUNT_KIND_SECRET",
+            secret: "valkey-tls",
+            destination: "/run/secrets/tls",
+        },
+    ]);
+    assert.equal(scope.value.command, null);
+});
+test("container_mount_remove command drives removeContainerMount for each kind", async () => {
+    const scope = fakeScope(baseValue());
+    const calls = [];
+    const resolver = {
+        getConfig: () => ({}),
+        setConfig: () => { },
+        async control(method, request) {
+            calls.push([method, request]);
+            if (method === "listContainers")
+                return { containers: [] };
+            if (method === "listImages")
+                return { images: [] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            return {};
+        },
+    };
+    await installCardCommandDriver(fakeContext(scope), resolver);
+    await scope.update({
+        command: {
+            op: "container_mount_remove",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 1,
+            mount: {
+                kind: "project",
+                project: "team/src",
+                destination: "/workspace/team",
+                mode: "read_write",
+                volume: "",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_remove",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 2,
+            mount: {
+                kind: "volume",
+                project: "",
+                destination: "",
+                mode: "read_write",
+                volume: "valkey-data",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_remove",
+            workspace: "w1",
+            container: "",
+            image: "",
+            at: 3,
+            mount: {
+                kind: "tmpfs",
+                project: "",
+                destination: "/dev/shm",
+                mode: "read_write",
+                volume: "",
+                secret: "",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: {
+            op: "container_mount_remove",
+            workspace: "w1",
+            container: "web",
+            image: "",
+            at: 4,
+            mount: {
+                kind: "secret",
+                project: "",
+                destination: "/run/secrets/tls",
+                mode: "read_write",
+                volume: "",
+                secret: "valkey-tls",
+            },
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    const removeCalls = calls.filter(([method]) => method === "removeContainerMount");
+    assert.deepEqual(removeCalls.map(([, request]) => request), [
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_PROJECT",
+            project: "team/src",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_VOLUME",
+            volume: "valkey-data",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "default",
+            kind: "MOUNT_KIND_TMPFS",
+            destination: "/dev/shm",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_SECRET",
+            secret: "valkey-tls",
+            destination: "/run/secrets/tls",
+        },
+    ]);
+    assert.equal(scope.value.command, null);
+});
+test("container_mount_update command drives updateContainerMount", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: mountCommand("container_mount_update", {
+            kind: "project",
+            project: "team",
+            mode: "read_only",
+        }),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    await scope.update({
+        command: mountCommand("container_mount_update", {
+            kind: "volume",
+            volume: "valkey-data",
+            destination: "/data",
+            mode: "read_write",
+        }),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    const updateCalls = calls.filter(([method]) => method === "updateContainerMount");
+    assert.deepEqual(updateCalls.map(([, request]) => request), [
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_PROJECT",
+            project: "team",
+            mode: "MOUNT_MODE_READ_ONLY",
+        },
+        {
+            workspaceSlug: "w1",
+            container: "web",
+            kind: "MOUNT_KIND_VOLUME",
+            volume: "valkey-data",
+            destination: "/data",
+            mode: "MOUNT_MODE_READ_WRITE",
+        },
+    ]);
+    assert.equal(scope.value.command, null);
+});
+test("container_mount_add command reports an unknown kind as a notice", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: mountCommand("container_mount_add", {
+            kind: "bind",
+            project: "team",
+            mode: "read_write",
+        }),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(scope.value.notice, "unknown mount kind: bind");
+    assert.equal(scope.value.command, null);
+    assert.equal(calls.some(([method]) => method === "addContainerMount"), false, "a rejected mount must not reach the orchestrator");
+});
+test("container_mount_add command reports an unknown mode as a notice", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: mountCommand("container_mount_add", {
+            kind: "project",
+            project: "team",
+            mode: "rw",
+        }),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(scope.value.notice, "unknown mount mode: rw");
+    assert.equal(scope.value.command, null);
+    assert.equal(calls.some(([method]) => method === "addContainerMount"), false, "a rejected mount must not reach the orchestrator");
+});
+test("container_mount_remove command reports an unknown kind as a notice", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: mountCommand("container_mount_remove", {
+            kind: "bind",
+            project: "team",
+        }),
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(scope.value.notice, "unknown mount kind: bind");
+    assert.equal(scope.value.command, null);
+    assert.equal(calls.some(([method]) => method === "removeContainerMount"), false, "a rejected mount must not reach the orchestrator");
+});
+test("create command reports an unknown mount kind as a notice", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: {
+            op: "create",
+            workspace: "w1",
+            image: "",
+            at: 1,
+            mounts: [{
+                    kind: "bind",
+                    project: "team",
+                    destination: "",
+                    mode: "read_write",
+                    volume: "",
+                    secret: "",
+                }],
+            env: {},
+            container: "",
+            secretEnvMap: {},
+            mount: null,
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(scope.value.notice, "unknown mount kind: bind");
+    assert.equal(scope.value.command, null);
+    assert.equal(calls.some(([method]) => method === "createWorkspace"), false, "a rejected mount must not reach the orchestrator");
+});
+test("create command reports an unknown mount mode as a notice", async () => {
+    const { scope, calls } = await installedMountScope();
+    await scope.update({
+        command: {
+            op: "create",
+            workspace: "w1",
+            image: "",
+            at: 1,
+            mounts: [{
+                    kind: "project",
+                    project: "team",
+                    destination: "",
+                    mode: "rw",
+                    volume: "",
+                    secret: "",
+                }],
+            env: {},
+            container: "",
+            secretEnvMap: {},
+            mount: null,
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.equal(scope.value.notice, "unknown mount mode: rw");
+    assert.equal(scope.value.command, null);
+    assert.equal(calls.some(([method]) => method === "createWorkspace"), false, "a rejected mount must not reach the orchestrator");
+});
+test("listContainers container mounts carry the raw proto fields", async () => {
+    const scope = fakeScope(baseValue());
+    const resolver = {
+        getConfig: () => ({}),
+        setConfig: () => { },
+        async control(method) {
+            if (method === "listContainers") {
+                return {
+                    containers: [{
+                            containerName: "c1",
+                            workspaceSlug: "w1",
+                            mounts: [{
+                                    projectName: "team/src",
+                                    destination: "/x",
+                                    kind: "MOUNT_KIND_PROJECT",
+                                    mode: "MOUNT_MODE_READ_WRITE",
+                                    volume: "",
+                                    secret: "",
+                                }],
+                        }],
+                };
+            }
+            if (method === "listImages")
+                return { images: [] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            return {};
+        },
+    };
+    await installCardCommandDriver(fakeContext(scope), resolver);
+    await scope.update({});
+    assert.deepEqual(scope.value.containers[0].mounts[0], {
+        projectName: "team/src",
+        destination: "/x",
+        kind: "MOUNT_KIND_PROJECT",
+        mode: "MOUNT_MODE_READ_WRITE",
+        volume: "",
+        secret: "",
+    });
+});

package/dist/settings-paths.test.d.ts

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

package/dist/settings-paths.test.js

@@ -0,0 +1,65 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import test from "node:test";
+import assert from "node:assert/strict";
+import { baseValue, fakeContext, fakeScope } from "./card-test-support.js";
+import { installCardCommandDriver } from "./card-test-support.js";
+import { WORKSPACE_ID } from "./test-support.js";
+test("container_path_set command persists the list and pushes it to the guest", async () => {
+    const scope = fakeScope(baseValue());
+    const calls = [];
+    const pushed = [];
+    const guest = {
+        setPaths: (request, _metadata, callback) => {
+            pushed.push(request.paths);
+            callback(null, { paths: request.paths });
+        },
+    };
+    const binding = { guest, token: "t", socket: "/run/x.sock" };
+    const resolver = {
+        getConfig: () => ({}),
+        setConfig: () => { },
+        resolve: async () => binding,
+        containerBinding: async () => binding,
+        async control(method, request) {
+            calls.push([method, request]);
+            if (method === "listContainers")
+                return { containers: [] };
+            if (method === "listImages")
+                return { images: [] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            return {};
+        },
+    };
+    await installCardCommandDriver(fakeContext(scope), resolver, {
+        list: () => [{ id: WORKSPACE_ID, path: "/projects/team" }],
+    });
+    await scope.update({});
+    await new Promise((resolve) => setImmediate(resolve));
+    calls.length = 0;
+    await scope.update({
+        command: {
+            op: "container_path_set",
+            workspace: WORKSPACE_ID,
+            container: "default",
+            image: "",
+            at: 1,
+            paths: ["/opt/bin", "/usr/local/bin"],
+            mounts: [],
+        },
+    });
+    await new Promise((resolve) => setImmediate(resolve));
+    assert.deepEqual(calls
+        .filter(([method]) => method === "setContainerPaths")
+        .map(([, request]) => request), [
+        {
+            workspaceSlug: WORKSPACE_ID,
+            container: "default",
+            paths: ["/opt/bin", "/usr/local/bin"],
+        },
+    ]);
+    assert.deepEqual(pushed, [["/opt/bin", "/usr/local/bin"]]);
+    assert.equal(scope.value.command, null);
+});

package/dist/settings-schema.d.ts

@@ -0,0 +1,14 @@
+import z from "@deepseek-ai/schemastery";
+export declare const CONTAINER_NS = "podman";
+export declare const settingsSchema: z<ContainerSettings>;
+export interface ContainerSettings {
+    defaultImage: string;
+    socketsRoot: string;
+    uiLocale: string;
+}
+export interface ContainerSettingsScope {
+    get(): ContainerSettings;
+    watch(callback: (next: ContainerSettings, prev: ContainerSettings) => void | Promise<void>): () => void;
+    update(patch: object): Promise<void>;
+    replace(section: object): Promise<void>;
+}

package/dist/settings-schema.js

@@ -0,0 +1,14 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import z from "@deepseek-ai/schemastery";
+export const CONTAINER_NS = "podman";
+// Only real preferences live in the settings namespace, so the settings
+// document holds user choices and nothing derived. The live orchestrator state
+// and the card's commands travel over the card route instead (see
+// card-protocol.ts).
+export const settingsSchema = z.object({
+    defaultImage: z.string().default(""),
+    socketsRoot: z.string().default(""),
+    uiLocale: z.string().default(""),
+});

package/dist/settings-workspaces.test.d.ts

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