aicodeman 1.3.5 → 1.4.1

package/dist/web/routes/case-routes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"case-routes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/case-routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAkB1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AA2B/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI,CAujB1F"}
+{"version":3,"file":"case-routes.d.ts","sourceRoot":"","sources":["../../../src/web/routes/case-routes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AA0B1C,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAiG/D,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,SAAS,GAAG,UAAU,GAAG,IAAI,CA89B1F"}

package/dist/web/routes/case-routes.js

@@ -3,21 +3,39 @@
  * Handles CRUD for cases (directories under ~/codeman-cases and linked folders),
  * fix-plan reading, and ralph-wizard file serving.
  */
-import { existsSync, mkdirSync, writeFileSync, readdirSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync, createReadStream } from 'node:fs';
+import { exec } from 'node:child_process';
 import fs from 'node:fs/promises';
-import { join, resolve } from 'node:path';
+import { join, resolve, basename } from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { homedir } from 'node:os';
 import { ApiErrorCode, createErrorResponse, getErrorMessage } from '../../types.js';
-import { CreateCaseSchema, LinkCaseSchema, CaseOrderSchema, RemoteCaseLinkSchema, RemoteHostSchema, } from '../schemas.js';
+import { CreateCaseSchema, LinkCaseSchema, CaseOrderSchema, RemoteCaseLinkSchema, RemoteHostSchema, DockerCaseLinkSchema, DockerHostSchema, DockerExportSchema, DockerImportSchema, DockerQuickCreateSchema, } from '../schemas.js';
+import { exportDockerCase, importDockerBundle, listDockerExports, exportBundleName } from '../../docker-export.js';
 import { generateClaudeMd } from '../../templates/claude-md.js';
 import { writeHooksConfig } from '../../hooks-config.js';
 import { CASES_DIR, SETTINGS_PATH, validatePathWithinBase, parseBody, readJsonConfig } from '../route-helpers.js';
 import { SseEvent } from '../sse-events.js';
 import { dataPath, getDataDir } from '../../config/instance.js';
+import { checkDockerAvailable, checkDockerImagePresent, checkDockerTmuxAvailable, ensureAgentBaseImage, DEFAULT_AGENT_IMAGE, dockerContainerName, dockerDisplayPath, readDockerCases, readDockerHosts, toSessionDocker, writeDockerCases, writeDockerHosts, } from '../../docker-hosts.js';
+import { buildDockerRemoveCommand } from '../../tmux-manager.js';
 import { checkRemoteTmuxAvailable, readRemoteCases, readRemoteHosts, remoteDisplayPath, writeRemoteCases, writeRemoteHosts, } from '../../remote-hosts.js';
 const LINKED_CASES_FILE = dataPath('linked-cases.json');
 const CODEMAN_CONFIG_DIR = getDataDir();
 const SAFE_CASE_NAME = /^[a-zA-Z0-9_-]+$/;
+const DOCKER_EXPORTS_DIR = dataPath('docker-exports');
+/** Auto-created host profile for the one-click "Run in Docker" case flow. */
+const DEFAULT_DOCKER_HOST_ID = 'default';
+/** App version for export manifests (best-effort read of package.json). */
+const APP_VERSION = (() => {
+    try {
+        const pkgPath = fileURLToPath(new URL('../../../package.json', import.meta.url));
+        return JSON.parse(readFileSync(pkgPath, 'utf-8')).version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+})();
 /** Read and parse linked-cases.json, returning empty object on missing/invalid file. */
 async function readLinkedCases() {
     return readJsonConfig(LINKED_CASES_FILE, 'linked cases', {});
@@ -29,6 +47,40 @@ async function resolveCasePath(name) {
         return linkedCases[name];
     return join(CASES_DIR, name);
 }
+/**
+ * Gate a docker case on its base image, AUTO-BUILDING the default image on first
+ * use so a missing image is never a blocker (the user's ask: "create it when it's
+ * used for the first time"). Present image → verify tmux (hard prerequisite).
+ * Default image missing → kick off a BACKGROUND build with SSE progress and return
+ * `imageBuilding: true` (the case is created regardless; first launch awaits the
+ * same dedup'd build). Custom image missing → a real error (we can't build a
+ * foreign ref, and `--pull=never` forbids pulling).
+ */
+async function ensureCaseImage(broadcast, sessionDocker, name) {
+    if (await checkDockerImagePresent(sessionDocker.engine, sessionDocker.image)) {
+        const tmuxCheck = await checkDockerTmuxAvailable(sessionDocker);
+        if (!tmuxCheck.ok)
+            return { ok: false, error: tmuxCheck.error || 'base image is missing tmux' };
+        return { ok: true, imageBuilding: false };
+    }
+    if (sessionDocker.image !== DEFAULT_AGENT_IMAGE) {
+        return {
+            ok: false,
+            error: `base image ${sessionDocker.image} not present; only ${DEFAULT_AGENT_IMAGE} is auto-built. Build or pull it first.`,
+        };
+    }
+    broadcast(SseEvent.DockerImageBuildStarted, { name, image: sessionDocker.image });
+    void ensureAgentBaseImage(sessionDocker.engine, sessionDocker.image, {
+        onProgress: (line) => broadcast(SseEvent.DockerImageBuildProgress, { name, line }),
+    })
+        .then((r) => broadcast(r.ok ? SseEvent.DockerImageBuildComplete : SseEvent.DockerImageBuildFailed, {
+        name,
+        image: sessionDocker.image,
+        error: r.error,
+    }))
+        .catch((err) => broadcast(SseEvent.DockerImageBuildFailed, { name, image: sessionDocker.image, error: getErrorMessage(err) }));
+    return { ok: true, imageBuilding: true };
+}
 export function registerCaseRoutes(app, ctx) {
     // ═══════════════════════════════════════════════════════════════
     // Case CRUD (list, create, link, detail, fix-plan)
@@ -95,6 +147,36 @@ export function registerCaseRoutes(app, ctx) {
                 cases[existingIndex] = remoteCaseInfo;
             }
         }
+        // Get docker cases
+        const dockerHosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        const dockerHostMap = new Map(dockerHosts.map((host) => [host.id, host]));
+        for (const dockerCase of await readDockerCases(CODEMAN_CONFIG_DIR)) {
+            const host = dockerHostMap.get(dockerCase.hostId);
+            if (!host || !SAFE_CASE_NAME.test(dockerCase.name))
+                continue;
+            existingNames.add(dockerCase.name);
+            const container = dockerCase.container ?? dockerContainerName(dockerCase.name);
+            const dockerCaseInfo = {
+                name: dockerCase.name,
+                path: dockerDisplayPath({ container, path: dockerCase.hostWorkspacePath }),
+                hasClaudeMd: existsSync(join(dockerCase.hostWorkspacePath, 'CLAUDE.md')),
+                location: 'docker',
+                docker: {
+                    hostId: host.id,
+                    container,
+                    image: host.image,
+                    path: dockerCase.hostWorkspacePath,
+                    network: host.network ?? 'bridge',
+                },
+            };
+            const existingIndex = cases.findIndex((item) => item.name === dockerCase.name);
+            if (existingIndex === -1) {
+                cases.push(dockerCaseInfo);
+            }
+            else {
+                cases[existingIndex] = dockerCaseInfo;
+            }
+        }
         // Sort by persisted caseOrder from settings.json
         const settings = await readJsonConfig(SETTINGS_PATH, 'settings', {});
         const caseOrder = Array.isArray(settings.caseOrder) ? settings.caseOrder : [];
@@ -189,6 +271,300 @@ export function registerCaseRoutes(app, ctx) {
         ctx.broadcast(SseEvent.CaseLinked, { name: remoteCase.name, path: remoteCase.remotePath, type: 'remote' });
         return { success: true, data: { case: remoteCase } };
     });
+    // ========== Docker hosts + docker cases (COD-Docker) ==========
+    app.get('/api/docker-hosts', async () => readDockerHosts(CODEMAN_CONFIG_DIR));
+    app.post('/api/docker-hosts', async (req) => {
+        const host = parseBody(DockerHostSchema, req.body);
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        if (hosts.some((item) => item.id === host.id)) {
+            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Docker host already exists');
+        }
+        await writeDockerHosts(CODEMAN_CONFIG_DIR, [...hosts, host]);
+        return { success: true, data: { host } };
+    });
+    app.put('/api/docker-hosts/:id', async (req) => {
+        const { id } = req.params;
+        const host = parseBody(DockerHostSchema, { ...req.body, id });
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        const index = hosts.findIndex((item) => item.id === id);
+        if (index === -1)
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Docker host not found');
+        const next = [...hosts];
+        next[index] = host;
+        await writeDockerHosts(CODEMAN_CONFIG_DIR, next);
+        return { success: true, data: { host } };
+    });
+    app.delete('/api/docker-hosts/:id', async (req) => {
+        const { id } = req.params;
+        const cases = await readDockerCases(CODEMAN_CONFIG_DIR);
+        if (cases.some((item) => item.hostId === id)) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, 'Docker host is still used by docker cases');
+        }
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        await writeDockerHosts(CODEMAN_CONFIG_DIR, hosts.filter((item) => item.id !== id));
+        return { success: true, data: { id } };
+    });
+    app.post('/api/cases/docker-link', async (req) => {
+        const dockerCase = { ...parseBody(DockerCaseLinkSchema, req.body), type: 'docker' };
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        const host = hosts.find((item) => item.id === dockerCase.hostId);
+        if (!host)
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Docker host not found');
+        const linkedCases = await readLinkedCases();
+        const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
+        if (dockerCases.some((item) => item.name === dockerCase.name) ||
+            linkedCases[dockerCase.name] ||
+            existsSync(join(CASES_DIR, dockerCase.name))) {
+            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
+        }
+        // The workspace is a REAL host directory (bind-mounted into the container), so
+        // create it now if missing. Scaffolding (.claude/settings.local.json + CLAUDE.md)
+        // is written by quick-start on first launch, matching local-case behaviour.
+        if (!existsSync(dockerCase.hostWorkspacePath)) {
+            try {
+                mkdirSync(dockerCase.hostWorkspacePath, { recursive: true });
+            }
+            catch (err) {
+                return createErrorResponse(ApiErrorCode.OPERATION_FAILED, `Could not create workspace: ${getErrorMessage(err)}`);
+            }
+        }
+        // Courtesy validation: docker daemon must be reachable. The base image is
+        // auto-built on first use (default image) rather than being a link-time
+        // blocker, so a missing image kicks off a background build instead of erroring.
+        const availability = await checkDockerAvailable(host.engine);
+        if (!availability.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
+        }
+        const imageGate = await ensureCaseImage(ctx.broadcast, toSessionDocker(host, dockerCase), dockerCase.name);
+        if (!imageGate.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, imageGate.error);
+        }
+        await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, dockerCase]);
+        ctx.broadcast(SseEvent.CaseLinked, {
+            name: dockerCase.name,
+            path: dockerCase.hostWorkspacePath,
+            type: 'docker',
+        });
+        return {
+            success: true,
+            data: {
+                case: dockerCase,
+                capsEnforced: availability.capsEnforced,
+                isDesktop: availability.isDesktop,
+                imageBuilding: imageGate.imageBuilding,
+            },
+        };
+    });
+    // One-click "Run in Docker": create a NORMAL case (folder in CASES_DIR, scaffolded)
+    // AND link it to a hardened container with default settings, auto-provisioning a
+    // shared `default` docker host so the user never touches host/image/network fields.
+    app.post('/api/cases/docker-quickcreate', async (req) => {
+        const body = parseBody(DockerQuickCreateSchema, req.body);
+        const { name, description } = body;
+        const casePath = validatePathWithinBase(name, CASES_DIR);
+        if (!casePath)
+            return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid case path');
+        // Collision across every case kind.
+        const linkedCases = await readLinkedCases();
+        const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
+        const remoteCases = await readRemoteCases(CODEMAN_CONFIG_DIR);
+        if (existsSync(casePath) ||
+            dockerCases.some((item) => item.name === name) ||
+            remoteCases.some((item) => item.name === name) ||
+            linkedCases[name]) {
+            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
+        }
+        // The checkbox alone (no overrides) uses the shared `default` host; any tweaked
+        // setting gets a dedicated per-case host so it never mutates the shared default.
+        const hasOverrides = !!(body.image ||
+            body.network ||
+            body.networkName ||
+            body.memory ||
+            body.cpus ||
+            body.gpus ||
+            body.mountCredentials !== undefined);
+        const resources = {};
+        if (body.memory)
+            resources.memory = body.memory;
+        if (body.cpus)
+            resources.cpus = body.cpus;
+        const desiredHost = {
+            id: hasOverrides ? `q-${name}` : DEFAULT_DOCKER_HOST_ID,
+            label: hasOverrides ? `Case: ${name}` : 'Default',
+            image: body.image || DEFAULT_AGENT_IMAGE,
+            network: body.network || 'bridge',
+            ...(body.networkName ? { networkName: body.networkName } : {}),
+            ...(Object.keys(resources).length ? { resources } : {}),
+            ...(body.gpus ? { gpus: body.gpus } : {}),
+            mountCredentials: body.mountCredentials ?? true,
+            resumeOnStart: true,
+            hooksEnabled: true,
+        };
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        const existing = hosts.find((item) => item.id === desiredHost.id);
+        // Reuse the shared default if present; create/refresh a per-case host for overrides.
+        const host = existing && !hasOverrides ? existing : desiredHost;
+        if (!existing) {
+            await writeDockerHosts(CODEMAN_CONFIG_DIR, [...hosts, desiredHost]);
+        }
+        else if (hasOverrides) {
+            await writeDockerHosts(CODEMAN_CONFIG_DIR, hosts.map((h) => (h.id === desiredHost.id ? desiredHost : h)));
+        }
+        // Probe the daemon BEFORE scaffolding so a missing docker surfaces a clear
+        // error instead of leaving an orphaned case folder. The base image is NOT a
+        // blocker: a missing default image auto-builds in the background on first use.
+        const availability = await checkDockerAvailable(host.engine);
+        if (!availability.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, availability.error || 'docker daemon is not available');
+        }
+        const dockerCase = { name, type: 'docker', hostId: host.id, hostWorkspacePath: casePath };
+        const imageGate = await ensureCaseImage(ctx.broadcast, toSessionDocker(host, dockerCase), name);
+        if (!imageGate.ok) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, imageGate.error);
+        }
+        // Scaffold the case folder exactly like a normal case.
+        try {
+            mkdirSync(casePath, { recursive: true });
+            mkdirSync(join(casePath, 'src'), { recursive: true });
+            const templatePath = await ctx.getDefaultClaudeMdPath();
+            writeFileSync(join(casePath, 'CLAUDE.md'), generateClaudeMd(name, description || '', templatePath));
+            await writeHooksConfig(casePath);
+        }
+        catch (err) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, `Failed to create case: ${getErrorMessage(err)}`);
+        }
+        await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, dockerCase]);
+        ctx.broadcast(SseEvent.CaseCreated, { name, path: casePath });
+        ctx.broadcast(SseEvent.CaseLinked, { name, path: casePath, type: 'docker' });
+        return {
+            success: true,
+            data: {
+                case: dockerCase,
+                capsEnforced: availability.capsEnforced,
+                isDesktop: availability.isDesktop,
+                imageBuilding: imageGate.imageBuilding,
+            },
+        };
+    });
+    // ========== Docker export / import ==========
+    // Export a docker case to a portable bundle. Runs in the BACKGROUND (a full image
+    // save can take minutes) and broadcasts docker:exportComplete / docker:exportFailed.
+    app.post('/api/docker-cases/:name/export', async (req) => {
+        const { name } = req.params;
+        const { mode = 'full' } = parseBody(DockerExportSchema, req.body ?? {});
+        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name);
+        if (!dockerCase)
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Docker case not found');
+        const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
+        if (!host)
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Docker host not found');
+        const sessionDocker = toSessionDocker(host, dockerCase);
+        if (mode === 'full' && !sessionDocker.mountCredentials) {
+            return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'full-image export is refused for a sealed container (its in-container login would ride the committed layer). Use a workspace-only export.');
+        }
+        const timestamp = Date.now();
+        const bundle = exportBundleName(name, timestamp, mode);
+        // Fire-and-forget: the client watches for the SSE completion event.
+        void exportDockerCase({
+            docker: sessionDocker,
+            caseName: name,
+            timestamp,
+            exportsDir: DOCKER_EXPORTS_DIR,
+            mode,
+            codemanVersion: APP_VERSION,
+        })
+            .then((result) => {
+            ctx.broadcast(SseEvent.DockerExportComplete, {
+                name,
+                bundle: basename(result.bundlePath),
+                sizeBytes: result.sizeBytes,
+                mode,
+            });
+        })
+            .catch((err) => {
+            ctx.broadcast(SseEvent.DockerExportFailed, { name, mode, error: getErrorMessage(err) });
+        });
+        return { success: true, data: { started: true, bundle } };
+    });
+    app.get('/api/docker-exports', async () => {
+        return { success: true, data: { exports: await listDockerExports(DOCKER_EXPORTS_DIR) } };
+    });
+    // Download an export bundle (filename resolved WITHIN the exports dir — no traversal).
+    app.get('/api/docker-exports/:filename', async (req, reply) => {
+        const { filename } = req.params;
+        if (!/^[a-zA-Z0-9._-]+\.tgz$/.test(filename)) {
+            return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid bundle filename');
+        }
+        const full = join(DOCKER_EXPORTS_DIR, filename);
+        if (!existsSync(full))
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Export not found');
+        reply.header('Content-Type', 'application/gzip');
+        reply.header('Content-Disposition', `attachment; filename="${filename}"`);
+        reply.header('X-Content-Type-Options', 'nosniff');
+        return reply.send(createReadStream(full));
+    });
+    app.delete('/api/docker-exports/:filename', async (req) => {
+        const { filename } = req.params;
+        if (!/^[a-zA-Z0-9._-]+\.tgz$/.test(filename)) {
+            return createErrorResponse(ApiErrorCode.INVALID_INPUT, 'Invalid bundle filename');
+        }
+        const full = join(DOCKER_EXPORTS_DIR, filename);
+        if (!existsSync(full))
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Export not found');
+        await fs.rm(full, { force: true });
+        return { success: true, data: { filename } };
+    });
+    // Import a bundle (already present in the exports dir) into a NEW docker case.
+    app.post('/api/docker-cases/import', async (req) => {
+        const { bundle, newCaseName, destWorkspacePath } = parseBody(DockerImportSchema, req.body);
+        const bundlePath = join(DOCKER_EXPORTS_DIR, bundle);
+        if (!existsSync(bundlePath))
+            return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Bundle not found in exports dir');
+        // Name-collision guard across ALL case kinds.
+        const linkedCases = await readLinkedCases();
+        const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
+        if (dockerCases.some((item) => item.name === newCaseName) ||
+            linkedCases[newCaseName] ||
+            existsSync(join(CASES_DIR, newCaseName))) {
+            return createErrorResponse(ApiErrorCode.ALREADY_EXISTS, 'Case already exists');
+        }
+        const timestamp = Date.now();
+        let result;
+        try {
+            result = await importDockerBundle({ bundlePath, destWorkspace: destWorkspacePath, engine: 'docker', timestamp });
+        }
+        catch (err) {
+            return createErrorResponse(ApiErrorCode.OPERATION_FAILED, `Import failed: ${getErrorMessage(err)}`);
+        }
+        // Create a dedicated docker host pointing at the quarantined imported image
+        // (full mode) or the manifest's base image (workspace-only).
+        const hostId = `imported-${newCaseName}`;
+        const hosts = await readDockerHosts(CODEMAN_CONFIG_DIR);
+        if (!hosts.some((h) => h.id === hostId)) {
+            await writeDockerHosts(CODEMAN_CONFIG_DIR, [
+                ...hosts,
+                {
+                    id: hostId,
+                    label: `Imported: ${newCaseName}`,
+                    engine: result.manifest.engine,
+                    image: result.importedImage ?? result.manifest.image,
+                    network: (['bridge', 'none', 'custom'].includes(result.manifest.network)
+                        ? result.manifest.network
+                        : 'bridge'),
+                },
+            ]);
+        }
+        const newCase = {
+            name: newCaseName,
+            type: 'docker',
+            hostId,
+            hostWorkspacePath: destWorkspacePath,
+            containerWorkdir: result.manifest.containerWorkdir,
+        };
+        await writeDockerCases(CODEMAN_CONFIG_DIR, [...dockerCases, newCase]);
+        ctx.broadcast(SseEvent.DockerImportComplete, { name: newCaseName, path: destWorkspacePath, type: 'docker' });
+        return { success: true, data: { case: newCase } };
+    });
     // Link an existing folder as a case
     app.post('/api/cases/link', async (req) => {
         const { name, path: folderPath } = parseBody(LinkCaseSchema, req.body, 'Invalid request body');
@@ -236,6 +612,29 @@ export function registerCaseRoutes(app, ctx) {
             ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'remote-unlinked' });
             return { success: true, data: { name } };
         }
+        const dockerCases = await readDockerCases(CODEMAN_CONFIG_DIR);
+        const dockerCase = dockerCases.find((item) => item.name === name);
+        if (dockerCase) {
+            await writeDockerCases(CODEMAN_CONFIG_DIR, dockerCases.filter((item) => item.name !== name));
+            // Best-effort `docker rm -f` the per-case container (case-delete is the
+            // explicit teardown that removes it; the bind-mounted workspace survives).
+            const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
+            if (host) {
+                const sessionDocker = toSessionDocker(host, dockerCase);
+                try {
+                    exec(buildDockerRemoveCommand(sessionDocker), { timeout: 15_000 }, () => { });
+                }
+                catch {
+                    /* best-effort — never blocks the unlink */
+                }
+                // Remove the per-container claude-config seed file (account metadata copy).
+                await fs
+                    .rm(join(dataPath('docker-seeds'), `${sessionDocker.containerName}.json`), { force: true })
+                    .catch(() => { });
+            }
+            ctx.broadcast(SseEvent.CaseDeleted, { name, type: 'docker-unlinked' });
+            return { success: true, data: { name } };
+        }
         // Check linked cases first — unlink only, don't delete the actual directory
         const linkedCases = await readLinkedCases();
         if (linkedCases[name]) {
@@ -311,6 +710,26 @@ export function registerCaseRoutes(app, ctx) {
                 },
             };
         }
+        const dockerCase = (await readDockerCases(CODEMAN_CONFIG_DIR)).find((item) => item.name === name);
+        if (dockerCase) {
+            const host = (await readDockerHosts(CODEMAN_CONFIG_DIR)).find((item) => item.id === dockerCase.hostId);
+            if (!host)
+                return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Docker host not found');
+            const container = dockerCase.container ?? dockerContainerName(dockerCase.name);
+            return {
+                name,
+                path: dockerDisplayPath({ container, path: dockerCase.hostWorkspacePath }),
+                hasClaudeMd: existsSync(join(dockerCase.hostWorkspacePath, 'CLAUDE.md')),
+                location: 'docker',
+                docker: {
+                    hostId: host.id,
+                    container,
+                    image: host.image,
+                    path: dockerCase.hostWorkspacePath,
+                    network: host.network ?? 'bridge',
+                },
+            };
+        }
         const casePath = await resolveCasePath(name);
         if (!existsSync(casePath)) {
             return createErrorResponse(ApiErrorCode.NOT_FOUND, 'Case not found');