@exagone313/dsh-podman 0.2.0-rc.2

package/dist/card-test-support.js

@@ -0,0 +1,160 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// Test doubles for the settings card. `installCardCommandDriver` stands in for
+// the browser transport: it hands each committed command to the real
+// `runCommand` and folds the real `cardSnapshot` back into the fake scope, so
+// the command tests stay focused on the command-to-control mapping. The HTTP
+// layer itself is covered by card-route.test.ts.
+import { strict as assert } from "node:assert";
+import { CONTAINER_NS, settingsSchema } from "./settings-schema.js";
+import { cardSnapshot, runCommand } from "./card-route.js";
+export function fakeScope(initial) {
+    const scope = {
+        value: { ...initial },
+        listeners: [],
+        async update(patch) {
+            const prev = scope.value;
+            scope.value = { ...scope.value, ...patch };
+            for (const listener of [...scope.listeners]) {
+                await listener(scope.value, prev);
+            }
+        },
+        watch(callback) {
+            scope.listeners.push(callback);
+            return () => {
+                scope.listeners = scope.listeners.filter((listener) => listener !== callback);
+            };
+        },
+    };
+    return scope;
+}
+export function fakeContext(scope) {
+    return {
+        inject(deps, callback) {
+            assert.deepEqual(deps, ["settings"]);
+            callback({
+                settings: {
+                    register() {
+                        return scope;
+                    },
+                    get() {
+                        return undefined;
+                    },
+                },
+            });
+        },
+    };
+}
+export function baseValue() {
+    return {
+        defaultImage: "archlinux",
+        socketsRoot: "/run/dsh-podman",
+        uiLocale: "",
+        notice: "",
+        command: null,
+        workspaces: [],
+        containers: [],
+        images: [],
+        volumes: [],
+        secrets: [],
+        caches: [],
+    };
+}
+// installCardCommandDriver wires a fake settings scope to the real command
+// runner and snapshot builder, standing in for the browser transport: it
+// mirrors what the card does per request — run the command, then refresh the
+// live snapshot and record the notice.
+export function installCardCommandDriver(ctx, resolver, registry) {
+    let installed = Promise.resolve();
+    ctx.inject(["settings"], (sctx) => {
+        const scope = sctx.settings.register(CONTAINER_NS, settingsSchema, {
+            base: {
+                defaultImage: resolver.getConfig().defaultImage,
+                socketsRoot: resolver.getConfig().socketsRoot,
+            },
+        });
+        const refresh = async (notice = "") => {
+            let view = {};
+            try {
+                const snapshot = await cardSnapshot(resolver, registry);
+                view = {
+                    workspaces: snapshot.workspaces,
+                    containers: snapshot.containers,
+                    images: snapshot.images,
+                    volumes: snapshot.volumes,
+                    secrets: snapshot.secrets,
+                    caches: snapshot.caches,
+                };
+            }
+            catch {
+                // Command tests do not always stub every list call.
+            }
+            await scope.update({ ...view, notice });
+        };
+        scope.watch((next) => {
+            resolver.setConfig({
+                defaultImage: next.defaultImage,
+                socketsRoot: next.socketsRoot,
+            });
+            const command = next.command;
+            if (command === null || command === undefined)
+                return;
+            void (async () => {
+                // Clear the command before running it, so the refresh below cannot
+                // re-deliver it.
+                await scope.update({ command: null });
+                let notice = "";
+                try {
+                    notice = await runCommand(sctx, resolver, registry, command);
+                }
+                catch (error) {
+                    notice = error instanceof Error ? error.message : String(error);
+                }
+                await refresh(notice);
+            })();
+        });
+        installed = refresh();
+    });
+    return installed;
+}
+export async function installedMountScope() {
+    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({}); // settle the queued async refresh
+    await new Promise((resolve) => setImmediate(resolve));
+    calls.length = 0;
+    return { scope, calls };
+}
+export function mountCommand(op, mount) {
+    return {
+        op,
+        workspace: "w1",
+        container: "web",
+        image: "",
+        mount: {
+            kind: "",
+            project: "",
+            destination: "",
+            mode: "",
+            volume: "",
+            secret: "",
+            ...mount,
+        },
+    };
+}

package/dist/client/ContainerCard.d.ts

@@ -0,0 +1,6 @@
+import { type ContainerCardFace } from "./container-card-controller.js";
+import { NS } from "./locales.js";
+import { type InjectFace, type PropsLocale, type PropsRuntime } from "@deepseek-ai/dsh-client-ui-slots";
+import { type ReactNode } from "react";
+export type ContainerCardProps = PropsRuntime<"settings.plugin.item"> & PropsLocale<typeof NS> & InjectFace<ContainerCardFace>;
+export declare function ContainerCard(props: ContainerCardProps): ReactNode;

package/dist/client/ContainerCard.js

@@ -0,0 +1,79 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import { BaseImageRow, ImageBuildModal, ImageItem } from "./container-card-images.js";
+import { CachesSection } from "./container-card-caches.js";
+import { SecretsSection } from "./container-card-secrets.js";
+import { CardChevron, ConfigField, ConfirmButton } from "./container-card-shared.js";
+import { banner, cardBodyStyle, cardDescriptionStyle, cardHeadTextStyle, cardHeaderStyle, cardHoverStyle, cardNameStyle, cardOpenStyle, cardStyle, footerRow, hint, imageSelect, sectionTitle, } from "./container-card-styles.js";
+import { VolumesSection } from "./container-card-volumes.js";
+import { WorkspaceSection } from "./container-card-workspace.js";
+import { Button, Input, Modal } from "@deepseek-ai/dsh-client-ui-primitives";
+import { useEffect, useId, useState } from "react";
+export function ContainerCard(props) {
+    const { t } = props;
+    const state = props.useContainerCard((snapshot) => snapshot);
+    const [open, setOpen] = useState(false);
+    const [hovered, setHovered] = useState(false);
+    const [buildOpen, setBuildOpen] = useState(false);
+    const [imageId, setImageId] = useState("");
+    const [parent, setParent] = useState("");
+    const [packages, setPackages] = useState([]);
+    const [defaultOpen, setDefaultOpen] = useState(false);
+    const [defaultImage, setDefaultImage] = useState(state.defaultImage);
+    const projectsRootId = useId();
+    // The card mounts with the settings panel, so this re-reads the live state
+    // every time the Plugins section is opened: a workspace created since the
+    // last read shows up without pressing Reload this view.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: mount-only refresh
+    useEffect(() => {
+        props.reload();
+    }, []);
+    const baseImages = state.images.filter((image) => image.isBase);
+    const customImages = state.images.filter((image) => !image.isBase);
+    const defaultCandidates = [
+        ...baseImages.map((image) => image.imageId),
+        ...customImages.map((image) => image.imageId),
+    ];
+    if (!state.available) {
+        return (_jsx("p", { style: { padding: "8px 0", fontSize: "13px", opacity: 0.8 }, children: t("unavailable") }));
+    }
+    return (_jsxs("li", { style: {
+            ...cardStyle,
+            ...(open ? cardOpenStyle : {}),
+            ...(hovered && !open ? cardHoverStyle : {}),
+        }, onPointerEnter: () => setHovered(true), onPointerLeave: () => setHovered(false), children: [_jsxs("button", { type: "button", style: cardHeaderStyle, "aria-expanded": open, onClick: () => setOpen(!open), children: [_jsxs("span", { style: cardHeadTextStyle, children: [_jsxs("span", { style: cardNameStyle, children: [t("cardTitle"), state.version ? ` ${state.version}` : "", state.commit ? ` · ${state.commit}` : ""] }), _jsx("span", { style: cardDescriptionStyle, children: t("cardDescription") })] }), _jsx(CardChevron, { open: open })] }), open ? (_jsxs("div", { style: cardBodyStyle, children: [state.notice === "" ? null : (_jsxs("div", { style: banner, role: "status", children: [t("notice"), ": ", state.notice] })), _jsx("div", { style: sectionTitle, children: t("workspacesTitle") }), state.workspaces.length === 0 ? (_jsx("p", { style: hint, children: t("none") })) : (state.workspaces.map((workspace) => (_jsx(WorkspaceSection, { t: t, workspace: workspace, containers: state.containers.filter((container) => container.workspaceSlug === workspace.workspaceSlug), images: state.images, volumes: state.volumes, secrets: state.secrets, busy: state.busy, defaultImage: state.defaultImage, projectsRoot: state.projectsRoot, directoryPicker: state.directoryPicker, onRemove: props.remove, onRemoveWorkspace: props.removeWorkspace, onRecreate: props.recreate, onCreate: props.createContainer, onStartContainer: props.startContainer, onAddContainerMount: props.addContainerMount, onRemoveContainerMount: props.removeContainerMount, onUpdateContainerMount: props.updateContainerMount, onSetContainerPaths: props.setContainerPaths, onAddContainerSecret: props.addContainerSecret, onRemoveContainerSecret: props.removeContainerSecret }, workspace.workspaceSlug)))), _jsxs("div", { style: {
+                            display: "flex",
+                            flexWrap: "wrap",
+                            alignItems: "center",
+                            gap: "8px",
+                        }, children: [_jsx("div", { style: { ...sectionTitle, flex: 1 }, children: t("imagesTitle") }), _jsx(Button, { variant: "outline", size: "sm", disabled: state.busy, onClick: () => {
+                                    setDefaultImage(state.defaultImage);
+                                    setDefaultOpen(true);
+                                }, children: t("setDefaultImage") }), _jsx(Button, { variant: "outline", size: "sm", disabled: state.busy, onClick: () => {
+                                    setImageId("");
+                                    setParent(baseImages[0]?.imageId ?? customImages[0]?.imageId ?? "");
+                                    setPackages([]);
+                                    setBuildOpen(true);
+                                }, children: t("buildImage") }), _jsx(ConfirmButton, { t: t, label: t("rebuildAllImages"), title: t("confirmTitle"), description: t("confirmRebuildAllImages"), disabled: state.busy, onConfirm: props.rebuildAllImages })] }), _jsx("div", { style: sectionTitle, children: t("baseImagesTitle") }), baseImages.length === 0 ? (_jsx("p", { style: hint, children: t("none") })) : (baseImages.map((image) => (_jsx(BaseImageRow, { t: t, image: image, busy: state.busy, defaultImage: state.defaultImage, onRebuild: props.rebuildBaseImage, onPull: props.pullBaseImage, onSetDefault: props.setDefaultImage }, image.imageId)))), _jsx("div", { style: sectionTitle, children: t("customImagesTitle") }), customImages.length === 0 ? (_jsx("p", { style: hint, children: t("none") })) : (customImages.map((image) => (_jsx(ImageItem, { t: t, image: image, busy: state.busy, defaultImage: state.defaultImage, onRemove: props.removeImage, onRebuild: props.rebuildImage, onSetDefault: props.setDefaultImage }, image.imageId)))), _jsx(ImageBuildModal, { t: t, images: state.images, open: buildOpen, imageId: imageId, parent: parent, packages: packages, onImageId: setImageId, onParent: setParent, onPackages: setPackages, onClose: () => setBuildOpen(false), onBuild: () => {
+                            props.buildImage(imageId.trim(), parent.trim(), packages);
+                            setImageId("");
+                            setParent("");
+                            setPackages([]);
+                            setBuildOpen(false);
+                        } }), _jsx(Modal, { open: defaultOpen, onClose: () => setDefaultOpen(false), title: t("setDefaultImageTitle"), closeLabel: t("cancel"), footer: _jsxs(_Fragment, { children: [_jsx(Button, { variant: "outline", size: "sm", onClick: () => setDefaultOpen(false), children: t("cancel") }), _jsx(Button, { variant: "primary", size: "sm", disabled: defaultImage === "", onClick: () => {
+                                        props.setDefaultImage(defaultImage);
+                                        setDefaultOpen(false);
+                                    }, children: t("setDefaultImage") })] }), children: _jsxs("select", { style: imageSelect, value: defaultImage, onChange: (event) => setDefaultImage(event.target.value), children: [defaultCandidates.length === 0 ? (_jsx("option", { value: "", children: t("none") })) : null, defaultCandidates.map((name) => (_jsx("option", { value: name, children: name }, name)))] }) }), _jsx(CachesSection, { t: t, caches: state.caches, busy: state.busy, onClean: props.cleanCaches }), _jsx(VolumesSection, { t: t, volumes: state.volumes, busy: state.busy, writable: state.writable, onCreate: props.createVolume, onRemove: props.removeVolume }), _jsx(SecretsSection, { t: t, secrets: state.secrets, busy: state.busy, writable: state.writable, onCreate: props.createSecret, onRemove: props.removeSecret, onSet: props.setSecret }), _jsx("div", { style: sectionTitle, children: t("configTitle") }), _jsxs("div", { style: {
+                            display: "flex",
+                            flexWrap: "wrap",
+                            alignItems: "center",
+                            gap: "8px",
+                            padding: "8px 0",
+                        }, children: [_jsx("label", { htmlFor: projectsRootId, style: {
+                                    fontSize: "13px",
+                                    color: "var(--dsw-alias-label-secondary)",
+                                    minWidth: "110px",
+                                }, children: t("projectsRoot") }), _jsx(Input, { id: projectsRootId, value: state.projectsRoot, disabled: true, style: { width: "200px" } })] }), _jsx(ConfigField, { t: t, label: t("socketsRoot"), value: state.socketsRootDraft, current: state.socketsRoot, writable: state.writable, onChange: props.editSocketsRoot, onSave: props.saveSocketsRoot, onDiscard: props.discardSocketsRoot }), _jsx("div", { style: footerRow, children: _jsx(Button, { variant: "outline", size: "sm", disabled: state.busy, onClick: props.reload, children: state.busy ? t("busy") : t("reload") }) })] })) : null] }));
+}

package/dist/client/card-client.d.ts

@@ -0,0 +1,6 @@
+import { type CardCommandResult, type CardSnapshot, type CommandRequest } from "./card-protocol.js";
+export interface CardClient {
+    snapshot(): Promise<CardSnapshot>;
+    command(request: CommandRequest): Promise<CardCommandResult>;
+}
+export declare function createCardClient(): CardClient;

package/dist/client/card-client.js

@@ -0,0 +1,47 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// The card's browser half of the host route. The route is served on the
+// harness API channel, so a same-origin fetch carries the browser session the
+// harness issued for it.
+import { CARD_PATH, } from "./card-protocol.js";
+// The route path already carries the harness API prefix, and a same-origin
+// fetch carries the browser session the harness issued for it.
+const CARD_URL = CARD_PATH;
+async function failure(response) {
+    try {
+        const body = (await response.json());
+        if (typeof body.error === "string" && body.error !== "") {
+            return new Error(body.error);
+        }
+    }
+    catch {
+        // A non-JSON body falls through to the status text.
+    }
+    return new Error(`card request failed (${response.status})`);
+}
+export function createCardClient() {
+    return {
+        async snapshot() {
+            const response = await fetch(CARD_URL, {
+                headers: { accept: "application/json" },
+            });
+            if (!response.ok)
+                throw await failure(response);
+            return (await response.json());
+        },
+        async command(request) {
+            const response = await fetch(CARD_URL, {
+                method: "POST",
+                headers: {
+                    accept: "application/json",
+                    "content-type": "application/json",
+                },
+                body: JSON.stringify({ command: request }),
+            });
+            if (!response.ok)
+                throw await failure(response);
+            return (await response.json());
+        },
+    };
+}

package/dist/client/card-protocol.d.ts

@@ -0,0 +1,101 @@
+export declare const CARD_PATH = "/api/podman/card";
+export interface MountInput {
+    kind: string;
+    project: string;
+    destination: string;
+    mode: string;
+    volume: string;
+    secret: string;
+}
+export type CommandOp = "remove" | "workspace_remove" | "recreate" | "create" | "volume_create" | "volume_remove" | "image_remove" | "secret_create" | "secret_remove" | "secret_set" | "image_rebuild" | "image_rebuild_all" | "image_build" | "image_base_rebuild" | "image_base_pull" | "container_secret_add" | "container_secret_remove" | "container_mount_add" | "container_mount_remove" | "container_mount_update" | "container_path_set" | "cache_clean";
+export interface CommandRequest {
+    op: CommandOp;
+    workspace: string;
+    projectName: string;
+    image: string;
+    mounts: readonly MountInput[];
+    paths: readonly string[];
+    value: string;
+    env: Record<string, string>;
+    container: string;
+    secret: string;
+    secretEnv: string;
+    length: number;
+    charset: string;
+    packages: string[];
+    secretEnvMap: Record<string, string>;
+    cacheMode: string;
+    mount: MountInput | null;
+}
+export interface ContainerView {
+    containerName: string;
+    workspaceSlug: string;
+    imageId: string;
+    status: string;
+    createdAt: string;
+    mounts: readonly {
+        projectName: string;
+        destination: string;
+        kind: string;
+        mode: string;
+        volume: string;
+        secret: string;
+    }[];
+    paths: readonly string[];
+    env: Record<string, string>;
+    secretEnv: Record<string, string>;
+}
+export interface ImageView {
+    imageId: string;
+    parent: string;
+    packages: readonly string[];
+    imageTag: string;
+    builtAt: string;
+    isBase: boolean;
+    status: string;
+    primitive: string;
+    packageManager: string;
+    basePublic: boolean;
+}
+export interface VolumeView {
+    name: string;
+}
+export interface SecretView {
+    name: string;
+}
+export interface CacheView {
+    manager: string;
+    path: string;
+    files: number;
+    bytes: number;
+}
+export interface WorkspaceView {
+    workspaceSlug: string;
+    projectName: string;
+    containerName: string;
+    imageId: string;
+    status: string;
+    createdAt: string;
+    mounts: readonly {
+        projectName: string;
+        mode: string;
+    }[];
+}
+/** The live orchestrator state the card renders. Nothing here is persisted. */
+export interface CardSnapshot {
+    version: string;
+    commit: string;
+    projectsRoot: string;
+    workspaces: readonly WorkspaceView[];
+    containers: readonly ContainerView[];
+    images: readonly ImageView[];
+    volumes: readonly VolumeView[];
+    secrets: readonly SecretView[];
+    caches: readonly CacheView[];
+}
+export interface CardCommandResult {
+    notice?: string;
+}
+export interface CardError {
+    error: string;
+}

package/dist/client/card-protocol.js

@@ -0,0 +1,10 @@
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+// The settings card talks to the host over one authenticated route on the
+// harness's connection service. These shapes are shared by both halves, and
+// neither the snapshot nor the commands touch the persisted settings document.
+// The full route path, harness API prefix included: the connection service
+// registers and matches the whole pathname (a path outside `/api/` is refused
+// at registration).
+export const CARD_PATH = "/api/podman/card";

package/dist/client/container-card-caches.d.ts

@@ -0,0 +1,10 @@
+import { type CacheView } from "./container-card-controller.js";
+import { NS } from "./locales.js";
+import { type TranslateNS } from "@deepseek-ai/dsh-client-ui-slots";
+import { type ReactNode } from "react";
+export declare function CachesSection(props: {
+    t: TranslateNS<typeof NS>;
+    caches: readonly CacheView[];
+    busy: boolean;
+    onClean: (mode: string) => void;
+}): ReactNode;

package/dist/client/container-card-caches.js

@@ -0,0 +1,31 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// SPDX-FileCopyrightText: 2026 Elouan Martinet <exa@elou.world>
+//
+// SPDX-License-Identifier: MIT
+import { ConfirmButton } from "./container-card-shared.js";
+import { hint, sectionTitle, wsBody } from "./container-card-styles.js";
+// Format a byte count with binary units, e.g. "1.2 GiB".
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "0 B";
+    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit += 1;
+    }
+    return `${unit === 0 ? String(value) : value.toFixed(1)} ${units[unit]}`;
+}
+// The package-manager build caches: their current size and the two cleanup
+// actions. The caches are re-downloadable, so neither action is destructive.
+export function CachesSection(props) {
+    const { t, caches, busy, onClean } = props;
+    const disabled = busy || caches.length === 0;
+    return (_jsxs(_Fragment, { children: [_jsx("div", { style: sectionTitle, children: t("cachesTitle") }), _jsxs("div", { style: wsBody, children: [caches.length === 0 ? (_jsx("p", { style: { ...hint, margin: 0 }, children: t("noCaches") })) : (caches.map((cache) => (_jsxs("div", { style: {
+                            display: "flex",
+                            flexWrap: "wrap",
+                            alignItems: "center",
+                            gap: "8px",
+                        }, children: [_jsx("strong", { style: { color: "var(--dsw-alias-label-primary)" }, children: cache.manager }), _jsx("span", { style: hint, children: t("cacheUsage", { size: formatBytes(cache.bytes), n: cache.files }) })] }, cache.manager)))), _jsxs("div", { style: { display: "flex", flexWrap: "wrap", gap: "8px" }, children: [_jsx(ConfirmButton, { t: t, label: t("cacheKeepLatest"), title: t("confirmTitle"), description: t("confirmCacheKeepLatest"), disabled: disabled, onConfirm: () => onClean("keep-latest") }), _jsx(ConfirmButton, { t: t, label: t("cacheRemoveAll"), title: t("confirmTitle"), description: t("confirmCacheRemoveAll"), disabled: disabled, onConfirm: () => onClean("all") })] })] })] }));
+}

package/dist/client/container-card-controller.d.ts

@@ -0,0 +1,107 @@
+import { type SnapshotStore } from "@deepseek-ai/dsh-client-store";
+import type { SettingsScope, SettingsScopeSnapshot } from "@deepseek-ai/dsh-client-ui-settings/client";
+import type { CacheView, ContainerView, ImageView, MountInput, SecretView, VolumeView, WorkspaceView } from "./card-protocol.js";
+import { type CardClient } from "./card-client.js";
+import { type DirectoryPickerFace } from "./directory-picker.js";
+export declare const CONTAINER_NS = "podman";
+export interface ContainerSettings {
+    defaultImage: string;
+    socketsRoot: string;
+    uiLocale?: string;
+}
+export interface ProjectMountView {
+    projectName: string;
+    destination: string;
+    kind: string;
+    mode: string;
+    volume: string;
+    secret: string;
+}
+export interface ContainerCreateConfig {
+    image?: string;
+    env?: Record<string, string>;
+    mounts?: readonly MountInput[];
+    paths?: readonly string[];
+    secretEnv?: Record<string, string>;
+}
+export type { CacheView, ContainerView, ImageView, MountInput, SecretView, VolumeView, WorkspaceView, };
+export interface CardState {
+    available: boolean;
+    writable: boolean;
+    busy: boolean;
+    notice: string;
+    version: string;
+    commit: string;
+    defaultImage: string;
+    defaultImageDraft: string;
+    socketsRoot: string;
+    socketsRootDraft: string;
+    projectsRoot: string;
+    directoryPicker?: DirectoryPickerFace;
+    workspaces: readonly WorkspaceView[];
+    containers: readonly ContainerView[];
+    images: readonly ImageView[];
+    volumes: readonly VolumeView[];
+    secrets: readonly SecretView[];
+    caches: readonly CacheView[];
+}
+export interface ContainerCardFace {
+    hooks: {
+        containerCard: SnapshotStore<CardState>;
+    };
+    reload: () => void;
+    remove: (workspace: string) => void;
+    cleanCaches: (mode: string) => void;
+    removeWorkspace: (workspace: string) => void;
+    recreate: (workspace: string, image: string, env?: Record<string, string>) => void;
+    createContainer: (workspace: WorkspaceView, config?: ContainerCreateConfig) => void;
+    startContainer: (workspace: WorkspaceView, container: string, config?: ContainerCreateConfig) => void;
+    addContainerMount: (workspace: string, container: string, mount: MountInput) => void;
+    removeContainerMount: (workspace: string, container: string, mount: MountInput) => void;
+    updateContainerMount: (workspace: string, container: string, mount: MountInput) => void;
+    setContainerPaths: (workspace: string, container: string, paths: readonly string[]) => void;
+    createVolume: (name: string) => void;
+    removeVolume: (name: string) => void;
+    removeImage: (imageId: string) => void;
+    rebuildImage: (imageId: string) => void;
+    rebuildAllImages: () => void;
+    buildImage: (imageId: string, parent: string, packages: string[]) => void;
+    rebuildBaseImage: (name: string) => void;
+    pullBaseImage: (name: string) => void;
+    setDefaultImage: (name: string) => void;
+    createSecret: (name: string, length?: number, charset?: string) => void;
+    removeSecret: (name: string) => void;
+    setSecret: (name: string, value: string) => void;
+    addContainerSecret: (workspace: string, envVar: string, secret: string) => void;
+    removeContainerSecret: (workspace: string, envVar: string) => void;
+    editDefaultImage: (text: string) => void;
+    saveDefaultImage: () => void;
+    discardDefaultImage: () => void;
+    editSocketsRoot: (text: string) => void;
+    saveSocketsRoot: () => void;
+    discardSocketsRoot: () => void;
+}
+export declare class ContainerCardController {
+    private readonly scope;
+    private readonly store;
+    private readonly drafts;
+    private readonly client;
+    private snapshot;
+    private busy;
+    private notice;
+    private directoryPicker;
+    constructor(scope: SettingsScope<ContainerSettings>, client?: CardClient);
+    private draft;
+    private project;
+    private publish;
+    setDirectoryPicker(picker: DirectoryPickerFace | undefined): void;
+    private command;
+    private dispatch;
+    private reload;
+    private edit;
+    private save;
+    private discard;
+    inject(): ContainerCardFace;
+    private defaultImage;
+}
+export type { SettingsScopeSnapshot };