@exagone313/dsh-podman 0.2.0-rc.2

package/dist/card-route.js

@@ -0,0 +1,478 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// The settings card's host half: one authenticated route below the harness API
+// path. It serves the live orchestrator snapshot and runs one command per
+// request, so neither the snapshot nor the commands touch the persisted
+// settings document.
+import { CARD_PATH, } from "./client/card-protocol.js";
+import { renderCacheCleanNotice, resolveReasonLocale } from "./approval-reasons.js";
+import { defaultMountMode, mountKindToProto, mountModeToProto } from "./mount-enums.js";
+import { unaryGuest } from "./guest-rpc.js";
+import { workspaceSlug } from "./workspace-binding.js";
+import { GIT_COMMIT, VERSION } from "./generated/version.js";
+// The cache clean modes the settings card can request, mapped to the control
+// plane's enum names.
+const CACHE_CLEAN_MODES = {
+    "keep-latest": "CACHE_CLEAN_MODE_KEEP_LATEST",
+    all: "CACHE_CLEAN_MODE_ALL",
+};
+function cacheCleanModeToProto(mode) {
+    const proto = Object.prototype.hasOwnProperty.call(CACHE_CLEAN_MODES, mode)
+        ? CACHE_CLEAN_MODES[mode]
+        : undefined;
+    if (proto === undefined)
+        throw new Error(`unknown cache clean mode: ${mode}`);
+    return proto;
+}
+function mountInputToProto(mount) {
+    const kind = mountKindToProto(mount.kind || undefined);
+    const mode = mountModeToProto(mount.mode || defaultMountMode(mount.kind || undefined));
+    const result = { projectName: mount.project ?? "", kind, mode };
+    if (kind !== "MOUNT_KIND_PROJECT" && mount.destination)
+        result.destination = mount.destination;
+    if (mount.volume)
+        result.volume = mount.volume;
+    if (mount.secret)
+        result.secret = mount.secret;
+    return result;
+}
+function orchestratorWorkspaceViews(raw) {
+    return (raw ?? []).map((workspace) => ({
+        workspaceSlug: workspace.workspaceSlug ?? "",
+        projectName: workspace.projectName ??
+            workspace.mounts?.[0]?.projectName ??
+            workspace.workspaceSlug ??
+            "",
+        containerName: workspace.containerName ?? "",
+        imageId: workspace.imageId ?? "",
+        status: workspace.status ?? "",
+        createdAt: workspace.createdAt ?? "",
+        mounts: (workspace.mounts ?? []).map((mount) => ({
+            projectName: mount.projectName ?? "",
+            mode: mount.mode ?? "",
+        })),
+    }));
+}
+function dshWorkspaceViews(registry, projectsRoot) {
+    const list = registry?.list?.() ?? [];
+    return list.map((workspace) => {
+        const path = String(workspace.path ?? "");
+        const projectName = path.startsWith(`${projectsRoot}/`)
+            ? path.slice(projectsRoot.length + 1)
+            : path;
+        return {
+            workspaceSlug: workspaceSlug(workspace.id),
+            projectName: projectName || String(workspace.title ?? "") || String(workspace.id ?? ""),
+            containerName: "",
+            imageId: "",
+            status: "",
+            createdAt: workspace.createdAt ?? "",
+            mounts: projectName !== "" ? [{ projectName, mode: "MOUNT_MODE_READ_WRITE" }] : [],
+        };
+    });
+}
+function mergeWorkspaceViews(dsh, orchestrator) {
+    const bySlug = new Map(orchestrator.map((workspace) => [workspace.workspaceSlug, workspace]));
+    const seen = new Set();
+    const merged = [];
+    for (const workspace of dsh) {
+        const existing = bySlug.get(workspace.workspaceSlug);
+        merged.push(existing ? { ...workspace, ...existing } : workspace);
+        seen.add(workspace.workspaceSlug);
+    }
+    for (const workspace of orchestrator) {
+        if (!seen.has(workspace.workspaceSlug))
+            merged.push(workspace);
+    }
+    return merged;
+}
+// dshWorkspaceCwd returns a registered dsh workspace's host path — the cwd the
+// resolver needs to bind a container for a card action.
+function dshWorkspaceCwd(registry, slug) {
+    for (const workspace of registry?.list?.() ?? []) {
+        if (workspaceSlug(workspace.id) === slug) {
+            return String(workspace.path ?? "");
+        }
+    }
+    throw new Error(`unknown workspace ${JSON.stringify(slug)}`);
+}
+/** Build the live snapshot the card renders. */
+export async function cardSnapshot(resolver, workspaceRegistry) {
+    const [containers, images, workspaces, volumes, secrets, caches] = await Promise.all([
+        resolver.control("listContainers", {}),
+        resolver.control("listImages", {}),
+        resolver.control("listWorkspaces", {}),
+        resolver.control("listVolumes", {}),
+        resolver.control("listSecrets", {}),
+        resolver.control("listCaches", {}),
+    ]);
+    return {
+        version: VERSION,
+        commit: GIT_COMMIT,
+        projectsRoot: resolver.getConfig().projectsRoot,
+        workspaces: mergeWorkspaceViews(dshWorkspaceViews(workspaceRegistry, resolver.getConfig().projectsRoot), orchestratorWorkspaceViews(workspaces.workspaces)),
+        containers: (containers.containers ?? []).map((container) => ({
+            containerName: container.containerName ?? "",
+            workspaceSlug: container.workspaceSlug ?? "",
+            imageId: container.imageId ?? "",
+            status: container.status ?? "",
+            createdAt: container.createdAt ?? "",
+            mounts: container.mounts ?? [],
+            paths: container.paths ?? [],
+            env: container.env ?? {},
+            secretEnv: container.secretEnv ?? {},
+        })),
+        images: images.images ?? [],
+        volumes: (volumes.volumes ?? []).map((volume) => ({
+            name: volume.name ?? "",
+        })),
+        secrets: (secrets.secrets ?? []).map((secret) => ({
+            name: secret.name ?? "",
+        })),
+        caches: (caches.caches ?? []).map((cache) => ({
+            manager: cache.manager ?? "",
+            path: cache.path ?? "",
+            files: Number(cache.files ?? 0),
+            // The control plane reports int64 as a string.
+            bytes: Number(cache.bytes ?? 0),
+        })),
+    };
+}
+/**
+ * Run one card command, returning the notice to show (usually empty). `ctx` is
+ * the settings-injected context, read only for the session locale.
+ */
+export async function runCommand(ctx, resolver, workspaceRegistry, raw) {
+    const command = normalizeCommand(raw);
+    let notice = "";
+    switch (command.op) {
+        case "create": {
+            const payload = {
+                workspaceSlug: command.workspace,
+                imageId: command.image === "" ? undefined : command.image,
+            };
+            const mounts = command.mounts.map(mountInputToProto);
+            if (mounts.length > 0)
+                payload.mounts = mounts;
+            if (Object.keys(command.env).length > 0)
+                payload.env = command.env;
+            if (Object.keys(command.secretEnvMap).length > 0) {
+                payload.secretEnv = command.secretEnvMap;
+            }
+            if (command.paths.length > 0)
+                payload.paths = [...command.paths];
+            if (command.container !== "") {
+                await resolver.control("startContainer", {
+                    ...payload,
+                    container: command.container,
+                });
+            }
+            else {
+                await resolver.control("createWorkspace", {
+                    ...payload,
+                    projectName: command.projectName,
+                });
+            }
+            break;
+        }
+        case "container_mount_add": {
+            const m = command.mount;
+            if (m === null)
+                break;
+            const kind = mountKindToProto(m.kind || undefined);
+            const mode = mountModeToProto(m.mode || defaultMountMode(m.kind || undefined));
+            const request = {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                kind,
+            };
+            if (kind === "MOUNT_KIND_VOLUME") {
+                request.volume = m.volume;
+                request.destination = m.destination;
+                request.mode = mode;
+            }
+            else if (kind === "MOUNT_KIND_TMPFS") {
+                request.destination = m.destination;
+                request.mode = mode;
+            }
+            else if (kind === "MOUNT_KIND_SECRET") {
+                request.secret = m.secret;
+                request.destination = m.destination;
+            }
+            else {
+                request.project = m.project;
+                request.mode = mode;
+            }
+            await resolver.control("addContainerMount", request);
+            break;
+        }
+        case "container_mount_remove": {
+            const m = command.mount;
+            if (m === null)
+                break;
+            const kind = mountKindToProto(m.kind || undefined);
+            const request = {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                kind,
+            };
+            if (kind === "MOUNT_KIND_PROJECT") {
+                request.project = m.project;
+            }
+            else if (kind === "MOUNT_KIND_VOLUME") {
+                if (m.volume)
+                    request.volume = m.volume;
+            }
+            else if (kind === "MOUNT_KIND_SECRET") {
+                if (m.secret)
+                    request.secret = m.secret;
+            }
+            if (kind !== "MOUNT_KIND_PROJECT" && m.destination) {
+                request.destination = m.destination;
+            }
+            await resolver.control("removeContainerMount", request);
+            break;
+        }
+        case "container_mount_update": {
+            const m = command.mount;
+            if (m === null)
+                break;
+            const kind = mountKindToProto(m.kind || undefined);
+            const request = {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                kind,
+                mode: mountModeToProto(m.mode),
+            };
+            if (kind === "MOUNT_KIND_PROJECT") {
+                request.project = m.project;
+            }
+            else if (kind === "MOUNT_KIND_VOLUME") {
+                if (m.volume)
+                    request.volume = m.volume;
+                if (m.destination)
+                    request.destination = m.destination;
+            }
+            await resolver.control("updateContainerMount", request);
+            break;
+        }
+        case "container_path_set": {
+            const paths = [...command.paths];
+            await resolver.control("setContainerPaths", {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                paths,
+            });
+            // The container is not recreated, so push the list to the running guest
+            // agent as well; the record above is what a recreate restores.
+            const cwd = dshWorkspaceCwd(workspaceRegistry, command.workspace);
+            const container = command.container || "default";
+            const binding = container === "default"
+                ? await resolver.resolve(cwd)
+                : await resolver.containerBinding(cwd, container);
+            await unaryGuest({ binding }, "setPaths", { paths });
+            break;
+        }
+        case "remove":
+            await resolver.control("removeContainer", {
+                workspaceSlug: command.workspace,
+            });
+            break;
+        case "workspace_remove":
+            await resolver.control("removeWorkspace", {
+                workspaceSlug: command.workspace,
+            });
+            break;
+        case "recreate":
+            await resolver.control("recreateContainer", {
+                workspaceSlug: command.workspace,
+                imageId: command.image === "" ? undefined : command.image,
+                ...(Object.keys(command.env).length > 0 ? { env: command.env } : {}),
+            });
+            break;
+        case "volume_create":
+            await resolver.control("createVolume", { name: command.workspace });
+            break;
+        case "volume_remove":
+            await resolver.control("removeVolume", { name: command.workspace });
+            break;
+        case "image_remove":
+            await resolver.control("removeImage", { imageId: command.workspace });
+            break;
+        case "secret_create":
+            await resolver.control("createSecret", {
+                name: command.workspace,
+                ...(command.length ? { length: command.length } : {}),
+                ...(command.charset ? { charset: command.charset } : {}),
+            });
+            break;
+        case "secret_remove":
+            await resolver.control("removeSecret", { name: command.workspace });
+            break;
+        case "secret_set":
+            await resolver.control("writeSecretValue", {
+                name: command.workspace,
+                value: command.value,
+            });
+            break;
+        case "image_rebuild":
+            await resolver.control("rebuildImage", { imageId: command.workspace });
+            break;
+        case "image_rebuild_all":
+            await resolver.control("rebuildAllImages", {});
+            break;
+        case "container_secret_add":
+            await resolver.control("addContainerSecret", {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                env: command.secretEnv,
+                secret: command.secret,
+            });
+            break;
+        case "container_secret_remove":
+            await resolver.control("removeContainerSecret", {
+                workspaceSlug: command.workspace,
+                container: command.container || "default",
+                env: command.secretEnv,
+            });
+            break;
+        case "image_build":
+            await resolver.control("buildImage", {
+                imageId: command.workspace,
+                parent: command.image,
+                packages: command.packages,
+            });
+            break;
+        case "image_base_rebuild":
+            await resolver.control("rebuildBaseImage", { name: command.workspace });
+            break;
+        case "image_base_pull":
+            await resolver.control("pullBaseImage", { name: command.workspace });
+            break;
+        case "cache_clean": {
+            const result = (await resolver.control("cleanCaches", {
+                mode: cacheCleanModeToProto(command.cacheMode),
+            }));
+            notice = renderCacheCleanNotice(resolveReasonLocale(ctx?.settings), Number(result.removedFiles ?? 0));
+            break;
+        }
+        default:
+            throw new Error(`unknown command ${JSON.stringify(command.op)}`);
+    }
+    return notice;
+}
+function jsonResponse(status, body) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { "content-type": "application/json" },
+    });
+}
+function stringField(value, fallback = "") {
+    return typeof value === "string" ? value : fallback;
+}
+function stringMap(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return {};
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        result[key] = String(item);
+    }
+    return result;
+}
+function mountField(value) {
+    if (typeof value !== "object" || value === null)
+        return null;
+    const mount = value;
+    return {
+        kind: stringField(mount.kind),
+        project: stringField(mount.project),
+        destination: stringField(mount.destination),
+        mode: stringField(mount.mode),
+        volume: stringField(mount.volume),
+        secret: stringField(mount.secret),
+    };
+}
+// normalizeCommand fills the defaults a caller may omit, so the command runner
+// can rely on every field being present. The route is a public endpoint, so it
+// must not trust the request body's shape.
+function normalizeCommand(raw) {
+    const mounts = Array.isArray(raw.mounts) ? raw.mounts : [];
+    return {
+        op: raw.op,
+        workspace: stringField(raw.workspace),
+        projectName: stringField(raw.projectName),
+        image: stringField(raw.image),
+        mounts: mounts.map((mount) => mountField(mount) ?? {
+            kind: "",
+            project: "",
+            destination: "",
+            mode: "",
+            volume: "",
+            secret: "",
+        }),
+        paths: Array.isArray(raw.paths) ? raw.paths.map(String) : [],
+        value: stringField(raw.value),
+        env: stringMap(raw.env),
+        container: stringField(raw.container),
+        secret: stringField(raw.secret),
+        secretEnv: stringField(raw.secretEnv),
+        length: typeof raw.length === "number" ? raw.length : 0,
+        charset: stringField(raw.charset),
+        packages: Array.isArray(raw.packages) ? raw.packages.map(String) : [],
+        secretEnvMap: stringMap(raw.secretEnvMap),
+        cacheMode: stringField(raw.cacheMode),
+        mount: mountField(raw.mount),
+    };
+}
+async function handleCardRequest(request, ctx, resolver, workspaceRegistry) {
+    if (request.method === "GET") {
+        try {
+            return jsonResponse(200, await cardSnapshot(resolver, workspaceRegistry));
+        }
+        catch (error) {
+            return jsonResponse(500, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    if (request.method !== "POST") {
+        return new Response("method not allowed", { status: 405 });
+    }
+    let command;
+    try {
+        const body = (await request.json());
+        command = body?.command;
+    }
+    catch {
+        return jsonResponse(400, { error: "invalid JSON body" });
+    }
+    if (command === null || typeof command !== "object") {
+        return jsonResponse(400, { error: "a command is required" });
+    }
+    try {
+        const notice = await runCommand(ctx, resolver, workspaceRegistry, command);
+        const result = notice === "" ? {} : { notice };
+        return jsonResponse(200, result);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const status = message.startsWith("unknown command") ? 400 : 500;
+        return jsonResponse(status, { error: message });
+    }
+}
+/**
+ * Register the card's authenticated fetch route. It is served below the
+ * harness API path, so the carrier applies its Host/Origin fence and browser
+ * authentication before the handler runs.
+ */
+export function registerCardRoute(ctx, resolver, workspaceRegistry) {
+    ctx.inject(["connection", "settings"], (connectionCtx) => {
+        connectionCtx.connection.fetch.register({
+            path: CARD_PATH,
+            methods: ["GET", "POST"],
+            requestBody: "buffered",
+            fetch: (request) => handleCardRequest(request, connectionCtx, resolver, workspaceRegistry),
+        });
+    });
+}

package/dist/card-route.test.d.ts

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

package/dist/card-route.test.js

@@ -0,0 +1,181 @@
+// 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 { CARD_PATH } from "./client/card-protocol.js";
+import { registerCardRoute } from "./card-route.js";
+import { installContainerPreferences } from "./preferences.js";
+function fakeResolver() {
+    const calls = [];
+    const resolver = {
+        getConfig: () => ({
+            defaultImage: "archlinux",
+            socketsRoot: "/run/dsh-podman",
+            projectsRoot: "/projects",
+        }),
+        setConfig: () => { },
+        async control(method, request) {
+            calls.push([method, request]);
+            if (method === "listContainers")
+                return { containers: [{ containerName: "c1" }] };
+            if (method === "listImages")
+                return { images: [{ imageId: "img1" }] };
+            if (method === "listWorkspaces")
+                return { workspaces: [] };
+            if (method === "listVolumes")
+                return { volumes: [{ name: "data" }] };
+            if (method === "listSecrets")
+                return { secrets: [{ name: "s1" }] };
+            if (method === "listCaches")
+                return { caches: [{ manager: "pacman", files: 1, bytes: "1024" }] };
+            if (method === "cleanCaches")
+                return { removedFiles: 2 };
+            if (method === "removeContainer")
+                return {};
+            return {};
+        },
+    };
+    return { resolver, calls };
+}
+function fakeRouteContext() {
+    const routes = [];
+    const ctx = {
+        inject(deps, callback) {
+            assert.deepEqual(deps, ["connection", "settings"]);
+            callback({
+                connection: {
+                    fetch: {
+                        register(route) {
+                            // Mirror the harness's assertFetchRoute: the route must live
+                            // under the API channel, or the registration is refused.
+                            if (!route.path.startsWith("/api/")) {
+                                throw new Error(`connection: invalid exact Fetch route ${JSON.stringify(route.path)}`);
+                            }
+                            routes.push(route);
+                            return async () => { };
+                        },
+                    },
+                },
+                settings: {
+                    register: () => ({ watch: () => () => { } }),
+                    get: () => undefined,
+                },
+            });
+        },
+    };
+    return { ctx, routes };
+}
+function cardRequest(init) {
+    return new Request(`http://dsh.test${CARD_PATH}`, init);
+}
+test("registerCardRoute registers the card's exact fetch route", () => {
+    assert.ok(CARD_PATH.startsWith("/api/"), "the route must live under the API channel");
+    const { resolver } = fakeResolver();
+    const { ctx, routes } = fakeRouteContext();
+    registerCardRoute(ctx, resolver);
+    assert.equal(routes.length, 1);
+    assert.equal(routes[0].path, CARD_PATH);
+    assert.deepEqual(routes[0].methods, ["GET", "POST"]);
+    assert.equal(routes[0].requestBody, "buffered");
+});
+test("the card route serves the live snapshot on GET", async () => {
+    const { resolver, calls } = fakeResolver();
+    const { ctx, routes } = fakeRouteContext();
+    registerCardRoute(ctx, resolver);
+    const response = await routes[0].fetch(cardRequest());
+    assert.equal(response.status, 200);
+    const snapshot = (await response.json());
+    assert.equal(snapshot.projectsRoot, "/projects");
+    assert.equal(snapshot.containers.length, 1);
+    assert.equal(snapshot.images.length, 1);
+    assert.deepEqual(snapshot.volumes, [{ name: "data" }]);
+    assert.deepEqual(snapshot.secrets, [{ name: "s1" }]);
+    assert.equal(snapshot.caches[0].bytes, 1024);
+    assert.deepEqual(calls.map(([method]) => method), ["listContainers", "listImages", "listWorkspaces", "listVolumes", "listSecrets", "listCaches"]);
+});
+test("the card route runs one command per POST and returns its notice", async () => {
+    const { resolver, calls } = fakeResolver();
+    const { ctx, routes } = fakeRouteContext();
+    registerCardRoute(ctx, resolver);
+    const remove = await routes[0].fetch(cardRequest({
+        method: "POST",
+        body: JSON.stringify({ command: { op: "remove", workspace: "w1" } }),
+    }));
+    assert.equal(remove.status, 200);
+    assert.deepEqual(await remove.json(), {});
+    assert.deepEqual(calls.find(([method]) => method === "removeContainer")?.[1], {
+        workspaceSlug: "w1",
+    });
+    const clean = await routes[0].fetch(cardRequest({
+        method: "POST",
+        body: JSON.stringify({ command: { op: "cache_clean", cacheMode: "all" } }),
+    }));
+    assert.equal(clean.status, 200);
+    assert.deepEqual(await clean.json(), { notice: "removed 2 cached files" });
+});
+test("the card route rejects a missing or unknown command", async () => {
+    const { resolver } = fakeResolver();
+    const { ctx, routes } = fakeRouteContext();
+    registerCardRoute(ctx, resolver);
+    const missing = await routes[0].fetch(cardRequest({ method: "POST", body: "{}" }));
+    assert.equal(missing.status, 400);
+    const unknown = await routes[0].fetch(cardRequest({
+        method: "POST",
+        body: JSON.stringify({ command: { op: "nope" } }),
+    }));
+    assert.equal(unknown.status, 400);
+    const malformed = await routes[0].fetch(cardRequest({ method: "POST", body: "not json" }));
+    assert.equal(malformed.status, 400);
+    const wrongMethod = await routes[0].fetch(cardRequest({ method: "DELETE" }));
+    assert.equal(wrongMethod.status, 405);
+});
+test("the card route reports a failed command as an error", async () => {
+    const resolver = {
+        getConfig: () => ({ projectsRoot: "/projects" }),
+        setConfig: () => { },
+        async control() {
+            throw new Error("control plane unavailable");
+        },
+    };
+    const { ctx, routes } = fakeRouteContext();
+    registerCardRoute(ctx, resolver);
+    const response = await routes[0].fetch(cardRequest({
+        method: "POST",
+        body: JSON.stringify({ command: { op: "remove", workspace: "w1" } }),
+    }));
+    assert.equal(response.status, 500);
+    assert.deepEqual(await response.json(), { error: "control plane unavailable" });
+});
+test("installContainerPreferences seeds the base and syncs the resolver config", () => {
+    let base;
+    let watcher;
+    const ctx = {
+        inject(deps, callback) {
+            assert.deepEqual(deps, ["settings"]);
+            callback({
+                settings: {
+                    register(_ns, _schema, options) {
+                        base = options.base;
+                        return {
+                            watch(callback) {
+                                watcher = callback;
+                                return () => { };
+                            },
+                        };
+                    },
+                },
+            });
+        },
+    };
+    const configs = [];
+    const resolver = {
+        getConfig: () => ({ defaultImage: "archlinux", socketsRoot: "/run/dsh-podman" }),
+        setConfig: (patch) => configs.push(patch),
+    };
+    installContainerPreferences(ctx, resolver);
+    assert.deepEqual(base, { defaultImage: "archlinux", socketsRoot: "/run/dsh-podman" });
+    assert.ok(watcher !== undefined);
+    watcher({ defaultImage: "ubuntu", socketsRoot: "/run/other" });
+    assert.deepEqual(configs, [{ defaultImage: "ubuntu", socketsRoot: "/run/other" }]);
+});

package/dist/card-test-support.d.ts

@@ -0,0 +1,15 @@
+export interface FakeScope {
+    value: Record<string, unknown>;
+    listeners: Array<(next: any, prev: any) => void>;
+    update: (patch: object) => Promise<void>;
+    watch: (callback: (next: any, prev: any) => void | Promise<void>) => () => void;
+}
+export declare function fakeScope(initial: Record<string, unknown>): FakeScope;
+export declare function fakeContext(scope: FakeScope): any;
+export declare function baseValue(): Record<string, unknown>;
+export declare function installCardCommandDriver(ctx: any, resolver: any, registry?: any): Promise<void>;
+export declare function installedMountScope(): Promise<{
+    scope: FakeScope;
+    calls: Array<[string, unknown]>;
+}>;
+export declare function mountCommand(op: string, mount: Record<string, string>): Record<string, unknown>;