chatccc 0.2.270 → 0.2.276

package/dist/deepccc-agent/src/web-server.js

@@ -0,0 +1,476 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import { stat } from "node:fs/promises";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MAX_ATTACHMENT_BYTES } from "./attachments.js";
+import { DEEPCCC_HOME, loadConfig, saveConfigPatch, } from "./config.js";
+import { killProcessTree } from "./proc-tree-kill.js";
+import { DeepCccWebRuntime } from "./web-runtime.js";
+import { DEEPCCC_WEB_PAGE } from "./web-page.js";
+const MAX_BODY_BYTES = 512 * 1024;
+const HOST = "127.0.0.1";
+let defaultHandle = null;
+export const DEEPCCC_WEB_STATE_FILE = join(DEEPCCC_HOME, "web", "server.json");
+function runtimeConfig() {
+    const config = loadConfig();
+    return {
+        provider: config.provider,
+        apiKey: config.apiKey,
+        baseURL: config.baseURL,
+        model: config.model,
+        subModel: config.subModel,
+        effort: config.effort,
+        maxOutputTokens: config.maxOutputTokens,
+        contextWindow: config.contextWindow,
+        streaming: config.streaming,
+    };
+}
+export function toPublicConfig(config, defaultCwd = process.cwd()) {
+    return {
+        provider: config.provider,
+        baseURL: config.baseURL,
+        model: config.model,
+        subModel: config.subModel,
+        effort: config.effort,
+        ...(config.maxOutputTokens ? { maxOutputTokens: config.maxOutputTokens } : {}),
+        streaming: config.streaming,
+        contextWindow: config.contextWindow,
+        web: config.web,
+        apiKeyConfigured: !!config.apiKey,
+        apiKeyMask: maskSecret(config.apiKey),
+        defaultCwd,
+    };
+}
+export function createDeepCccWebRequestHandler(options) {
+    return async function handle(req, res) {
+        const url = new URL(req.url ?? "/", `http://${HOST}`);
+        const path = url.pathname;
+        const method = req.method ?? "GET";
+        try {
+            if (method === "GET" && (path === "/" || path === "/index.html")) {
+                return textReply(res, 200, DEEPCCC_WEB_PAGE, "text/html; charset=utf-8");
+            }
+            if (method === "GET" && path === "/api/health") {
+                return jsonReply(res, 200, {
+                    ok: true,
+                    service: "deepccc-web",
+                    ...(options.instance ? {
+                        pid: options.instance.pid,
+                        port: options.instance.port,
+                        startedAt: options.instance.startedAt,
+                        instanceToken: options.instance.token,
+                    } : {}),
+                });
+            }
+            if (method === "POST" && path === "/api/shutdown") {
+                if (!options.instance || req.headers["x-deepccc-instance-token"] !== options.instance.token) {
+                    throw new WebHttpError(403, "DeepCCC Web shutdown token mismatch");
+                }
+                jsonReply(res, 202, { ok: true, shuttingDown: true });
+                setTimeout(options.instance.shutdown, 0).unref?.();
+                return;
+            }
+            if (method === "GET" && path === "/api/config") {
+                return jsonReply(res, 200, { ok: true, config: { ...options.getPublicConfig(), defaultCwd: options.defaultCwd } });
+            }
+            if (method === "PUT" && path === "/api/config") {
+                const body = await readJson(req);
+                const config = await options.saveConfig(body);
+                return jsonReply(res, 200, { ok: true, config: { ...config, defaultCwd: options.defaultCwd } });
+            }
+            if (method === "GET" && path === "/api/sessions") {
+                return jsonReply(res, 200, { ok: true, sessions: await options.runtime.listSessions() });
+            }
+            if (method === "GET" && path === "/api/events") {
+                return openGlobalEventStream(req, res, options.runtime);
+            }
+            if (method === "POST" && path === "/api/sessions") {
+                const body = await readJson(req);
+                const cwd = body.cwd?.trim() || options.defaultCwd;
+                await assertDirectory(cwd);
+                const session = await options.runtime.createSession({ ...body, cwd });
+                return jsonReply(res, 201, { ok: true, session });
+            }
+            const attachmentMatch = path.match(/^\/api\/sessions\/([^/]+)\/attachments(?:\/([^/]+))?$/);
+            if (attachmentMatch) {
+                const sessionId = decodeURIComponent(attachmentMatch[1]);
+                const attachmentId = attachmentMatch[2] ? decodeURIComponent(attachmentMatch[2]) : "";
+                if (method === "POST" && !attachmentId) {
+                    const originalName = url.searchParams.get("name")?.trim() || "image";
+                    const bytes = await readBinary(req, MAX_ATTACHMENT_BYTES);
+                    const attachment = await options.runtime.addAttachment(sessionId, { originalName, bytes });
+                    return jsonReply(res, 201, { ok: true, attachment });
+                }
+                if (method === "GET" && attachmentId) {
+                    const stored = await options.runtime.readAttachment(sessionId, attachmentId);
+                    if (!stored)
+                        return jsonReply(res, 404, { ok: false, error: "Image attachment not found" });
+                    return binaryReply(res, 200, stored.bytes, stored.attachment.mimeType, stored.attachment.originalName);
+                }
+                if (method === "DELETE" && attachmentId) {
+                    const deleted = await options.runtime.deleteAttachment(sessionId, attachmentId);
+                    return jsonReply(res, deleted ? 200 : 404, { ok: deleted });
+                }
+            }
+            const artifactMatch = path.match(/^\/api\/sessions\/([^/]+)\/artifact$/);
+            if (artifactMatch && method === "GET") {
+                const artifactPath = url.searchParams.get("path") ?? "";
+                if (!artifactPath)
+                    throw new WebHttpError(400, "Artifact path is required");
+                const artifact = await options.runtime.readArtifact(decodeURIComponent(artifactMatch[1]), artifactPath);
+                if (!artifact)
+                    return jsonReply(res, 404, { ok: false, error: "Artifact image not found" });
+                return binaryReply(res, 200, artifact.bytes, artifact.mimeType, artifact.path.split(/[\\/]/).at(-1) ?? "image");
+            }
+            const sessionMatch = path.match(/^\/api\/sessions\/([^/]+)$/);
+            if (sessionMatch && method === "GET") {
+                return jsonReply(res, 200, { ok: true, session: await options.runtime.getSession(decodeURIComponent(sessionMatch[1])) });
+            }
+            if (sessionMatch && method === "PATCH") {
+                const body = await readJson(req);
+                const session = await options.runtime.updateSession(decodeURIComponent(sessionMatch[1]), {
+                    ...(typeof body.title === "string" ? { title: body.title } : {}),
+                    ...(typeof body.model === "string" ? { model: body.model } : {}),
+                    ...(typeof body.subModel === "string" ? { subModel: body.subModel } : {}),
+                    ...(typeof body.effort === "string" ? { effort: body.effort } : {}),
+                });
+                return jsonReply(res, 200, { ok: true, session });
+            }
+            if (sessionMatch && method === "DELETE") {
+                const deleted = await options.runtime.deleteSession(decodeURIComponent(sessionMatch[1]));
+                return jsonReply(res, deleted ? 200 : 404, { ok: deleted });
+            }
+            const messagesMatch = path.match(/^\/api\/sessions\/([^/]+)\/messages$/);
+            if (messagesMatch && method === "POST") {
+                const body = await readJson(req);
+                const attachmentIds = Array.isArray(body.attachmentIds)
+                    ? body.attachmentIds.filter((value) => typeof value === "string")
+                    : [];
+                const result = await options.runtime.sendMessage(decodeURIComponent(messagesMatch[1]), body.text ?? "", attachmentIds);
+                return jsonReply(res, 202, { ok: true, ...result });
+            }
+            const stopMatch = path.match(/^\/api\/sessions\/([^/]+)\/stop$/);
+            if (stopMatch && method === "POST") {
+                return jsonReply(res, 200, { ok: true, stopped: await options.runtime.stopSession(decodeURIComponent(stopMatch[1])) });
+            }
+            const eventsMatch = path.match(/^\/api\/sessions\/([^/]+)\/events$/);
+            if (eventsMatch && method === "GET") {
+                return openEventStream(req, res, decodeURIComponent(eventsMatch[1]), options.runtime);
+            }
+            const approvalMatch = path.match(/^\/api\/approvals\/([^/]+)$/);
+            if (approvalMatch && method === "POST") {
+                const body = await readJson(req);
+                if (!body.answer || !["allow", "allow-session", "allow-always", "deny"].includes(body.answer)) {
+                    throw new WebHttpError(400, "Invalid approval answer");
+                }
+                const resolved = await options.runtime.resolveApproval(decodeURIComponent(approvalMatch[1]), body.answer);
+                return jsonReply(res, resolved ? 200 : 404, { ok: resolved });
+            }
+            if (path.startsWith("/api/"))
+                return jsonReply(res, 404, { ok: false, error: "Not found" });
+            if (method === "GET")
+                return textReply(res, 200, DEEPCCC_WEB_PAGE, "text/html; charset=utf-8");
+            return jsonReply(res, 404, { ok: false, error: "Not found" });
+        }
+        catch (err) {
+            const status = err instanceof WebHttpError ? err.status : 500;
+            jsonReply(res, status, { ok: false, error: err instanceof Error ? err.message : String(err) });
+        }
+    };
+}
+export async function startDeepCccWebServer(options = {}) {
+    const config = loadConfig();
+    const port = options.port ?? config.web.port;
+    const url = `http://${HOST}:${port}/`;
+    if (defaultHandle?.port === port) {
+        if (options.reuseExisting) {
+            if (options.openBrowser !== false)
+                openBrowser(url);
+            return defaultHandle;
+        }
+        await defaultHandle.close();
+    }
+    const stateFile = options.stateFile ?? DEEPCCC_WEB_STATE_FILE;
+    const existing = await inspectDeepCccWebServer(port);
+    if (existing && options.reuseExisting) {
+        const reused = { url, port, reused: true, close: async () => { } };
+        if (options.openBrowser !== false)
+            openBrowser(url);
+        return reused;
+    }
+    if (existing)
+        await stopOwnedDeepCccWebServer(existing, stateFile);
+    const runtime = new DeepCccWebRuntime({ loadConfig: runtimeConfig });
+    const defaultCwd = options.defaultCwd ?? process.cwd();
+    const instance = {
+        pid: process.pid,
+        port,
+        startedAt: new Date().toISOString(),
+        token: randomUUID(),
+    };
+    let closeServer = () => { };
+    const handler = createDeepCccWebRequestHandler({
+        runtime,
+        defaultCwd,
+        getPublicConfig: () => toPublicConfig(loadConfig(), defaultCwd),
+        saveConfig: (patch) => toPublicConfig(saveConfigPatch(patch), defaultCwd),
+        instance: { ...instance, shutdown: () => closeServer() },
+    });
+    const server = createServer((req, res) => { void handler(req, res); });
+    await new Promise((resolve, reject) => {
+        const onError = (err) => reject(err);
+        server.once("error", onError);
+        server.listen(port, HOST, () => {
+            server.off("error", onError);
+            resolve();
+        });
+    });
+    const handle = {
+        url,
+        port,
+        reused: false,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => {
+                if (err)
+                    return reject(err);
+                removeOwnedState(stateFile, instance.token);
+                if (defaultHandle?.port === port)
+                    defaultHandle = null;
+                resolve();
+            });
+            // SSE and keep-alive sockets would otherwise keep a replaced standalone
+            // process alive after it has released the listening port.
+            server.closeAllConnections?.();
+        }),
+    };
+    closeServer = () => { void handle.close(); };
+    defaultHandle = handle;
+    writeOwnedState(stateFile, instance);
+    if (options.openBrowser ?? config.web.openOnStart)
+        openBrowser(url);
+    return handle;
+}
+export async function launchDeepCccWebProcess(options = {}) {
+    const config = loadConfig();
+    const port = options.port ?? config.web.port;
+    const url = `http://${HOST}:${port}/`;
+    if (options.reuseExisting && await inspectDeepCccWebServer(port)) {
+        if (options.openBrowser !== false)
+            openBrowser(url);
+        return { url, port, reused: true };
+    }
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const compiledEntry = join(moduleDir, "web-entry.js");
+    const args = [
+        ...(options.reuseExisting ? ["--reuse-existing"] : []),
+        "--port", String(port),
+        ...(options.openBrowser === false ? ["--no-open"] : []),
+    ];
+    const require = createRequire(import.meta.url);
+    const commandArgs = existsSync(compiledEntry)
+        ? [compiledEntry, ...args]
+        : [require.resolve("tsx/cli"), join(moduleDir, "web-entry.ts"), ...args];
+    const child = spawn(process.execPath, commandArgs, {
+        cwd: options.defaultCwd ?? process.cwd(),
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.unref();
+    const deadline = Date.now() + 8_000;
+    while (Date.now() < deadline) {
+        if (await inspectDeepCccWebServer(port))
+            return { url, port, reused: false };
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`DeepCCC Web did not become ready on port ${port}`);
+}
+function openEventStream(req, res, sessionId, runtime) {
+    res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+    });
+    res.write(": connected\n\n");
+    const send = (event) => res.write(`id: ${event.eventId}\ndata: ${JSON.stringify(event)}\n\n`);
+    const unsubscribe = runtime.subscribe(sessionId, send);
+    const heartbeat = setInterval(() => res.write(": heartbeat\n\n"), 15_000);
+    heartbeat.unref?.();
+    req.on("close", () => { clearInterval(heartbeat); unsubscribe(); });
+}
+function openGlobalEventStream(req, res, runtime) {
+    res.writeHead(200, {
+        "content-type": "text/event-stream; charset=utf-8",
+        "cache-control": "no-cache, no-transform",
+        connection: "keep-alive",
+        "x-accel-buffering": "no",
+    });
+    res.write(": connected\n\n");
+    const send = (event) => res.write(`id: ${event.eventId}\ndata: ${JSON.stringify(event)}\n\n`);
+    const unsubscribe = runtime.subscribeAll(send);
+    const heartbeat = setInterval(() => res.write(": heartbeat\n\n"), 15_000);
+    heartbeat.unref?.();
+    req.on("close", () => { clearInterval(heartbeat); unsubscribe(); });
+}
+async function readJson(req) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > MAX_BODY_BYTES)
+            throw new WebHttpError(413, "Request body is too large");
+        chunks.push(buffer);
+    }
+    if (!chunks.length)
+        return {};
+    try {
+        return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    }
+    catch {
+        throw new WebHttpError(400, "Invalid JSON body");
+    }
+}
+async function readBinary(req, maxBytes) {
+    const chunks = [];
+    let bytes = 0;
+    for await (const chunk of req) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        bytes += buffer.length;
+        if (bytes > maxBytes)
+            throw new WebHttpError(413, "Image attachment exceeds the 20 MB limit");
+        chunks.push(buffer);
+    }
+    if (!chunks.length)
+        throw new WebHttpError(400, "Image attachment must not be empty");
+    return Buffer.concat(chunks);
+}
+async function assertDirectory(path) {
+    try {
+        if (!(await stat(path)).isDirectory())
+            throw new Error("not a directory");
+    }
+    catch {
+        throw new WebHttpError(400, `工作目录不存在：${path}`);
+    }
+}
+function maskSecret(value) {
+    if (!value)
+        return "";
+    const suffix = value.slice(-4);
+    return `${value.slice(0, Math.min(3, Math.max(0, value.length - 4)))}••••${suffix}`;
+}
+function jsonReply(res, status, value) {
+    res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+    res.end(JSON.stringify(value));
+}
+function textReply(res, status, value, contentType) {
+    res.writeHead(status, { "content-type": contentType, "cache-control": "no-store" });
+    res.end(value);
+}
+function binaryReply(res, status, value, contentType, fileName) {
+    res.writeHead(status, {
+        "content-type": contentType,
+        "content-length": String(value.byteLength),
+        "content-disposition": `inline; filename*=UTF-8''${encodeURIComponent(fileName)}`,
+        "cache-control": "no-store",
+        "x-content-type-options": "nosniff",
+    });
+    res.end(value);
+}
+class WebHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+export async function inspectDeepCccWebServer(port) {
+    try {
+        const response = await fetch(`http://${HOST}:${port}/api/health`, { signal: AbortSignal.timeout(800) });
+        if (!response.ok)
+            return null;
+        const health = await response.json();
+        if (health.service !== "deepccc-web")
+            return null;
+        return {
+            service: "deepccc-web",
+            pid: typeof health.pid === "number" ? health.pid : 0,
+            port: typeof health.port === "number" ? health.port : port,
+            startedAt: typeof health.startedAt === "string" ? health.startedAt : "",
+            token: typeof health.instanceToken === "string" ? health.instanceToken : "",
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function stopOwnedDeepCccWebServer(existing, stateFile) {
+    const owned = readOwnedState(stateFile);
+    if (!owned || !sameInstance(owned, existing)) {
+        throw new Error(`Port ${existing.port} is occupied by an unverified DeepCCC Web instance; use --reuse-existing or stop it manually`);
+    }
+    try {
+        await fetch(`http://${HOST}:${existing.port}/api/shutdown`, {
+            method: "POST",
+            headers: { "x-deepccc-instance-token": existing.token },
+            signal: AbortSignal.timeout(1_500),
+        });
+    }
+    catch { /* fall through to verified force-kill */ }
+    const deadline = Date.now() + 3_000;
+    while (Date.now() < deadline) {
+        if (!await inspectDeepCccWebServer(existing.port))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    const current = await inspectDeepCccWebServer(existing.port);
+    if (current && sameInstance(owned, current))
+        await killProcessTree(owned.pid);
+    const finalDeadline = Date.now() + 3_000;
+    while (Date.now() < finalDeadline) {
+        if (!await inspectDeepCccWebServer(existing.port))
+            return;
+        await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+    throw new Error(`Verified DeepCCC Web process ${owned.pid} did not release port ${existing.port}`);
+}
+function sameInstance(left, right) {
+    return left.pid > 0 && left.pid === right.pid && left.port === right.port && !!left.token && left.token === right.token && left.startedAt === right.startedAt;
+}
+function readOwnedState(path) {
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        if (typeof value.pid !== "number" || typeof value.port !== "number" || typeof value.startedAt !== "string" || typeof value.token !== "string")
+            return null;
+        return value;
+    }
+    catch {
+        return null;
+    }
+}
+function writeOwnedState(path, instance) {
+    mkdirSync(dirname(path), { recursive: true });
+    const temp = `${path}.${process.pid}.tmp`;
+    writeFileSync(temp, `${JSON.stringify(instance, null, 2)}\n`, "utf8");
+    renameSync(temp, path);
+}
+function removeOwnedState(path, token) {
+    if (readOwnedState(path)?.token !== token)
+        return;
+    try {
+        unlinkSync(path);
+    }
+    catch { /* already removed */ }
+}
+function openBrowser(url) {
+    const command = process.platform === "win32" ? "cmd" : process.platform === "darwin" ? "open" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
+    const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+    child.unref();
+}

package/dist/deepccc-agent/src/web-session-store.js

@@ -0,0 +1,162 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { DEFAULT_BUILTIN_CONTEXT_DIR, getBuiltinContextSession, normalizeBuiltinSessionId, } from "./context.js";
+export class WebSessionStore {
+    rootDir;
+    now;
+    idFactory;
+    constructor(options = {}) {
+        this.rootDir = options.rootDir ?? DEFAULT_BUILTIN_CONTEXT_DIR;
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? (() => `web-${randomUUID()}`);
+    }
+    async create(input) {
+        const cwd = cleanCwd(input.cwd);
+        const timestamp = this.now().toISOString();
+        const sessionId = normalizeBuiltinSessionId(this.idFactory());
+        const meta = {
+            schemaVersion: 1,
+            sessionId,
+            title: cleanTitle(input.title) || basename(cwd) || "新会话",
+            cwd,
+            model: input.model?.trim() ?? "",
+            subModel: input.subModel?.trim() ?? "",
+            effort: input.effort?.trim() ?? "",
+            createdAt: timestamp,
+            updatedAt: timestamp,
+            approvals: [],
+        };
+        await this.save(meta);
+        return meta;
+    }
+    async get(sessionId) {
+        const normalized = normalizeBuiltinSessionId(sessionId);
+        try {
+            return parseMeta(JSON.parse(await readFile(this.metaPath(normalized), "utf8")));
+        }
+        catch (err) {
+            if (err.code === "ENOENT") {
+                const context = getBuiltinContextSession(normalized, this.rootDir);
+                if (!context)
+                    return null;
+                const cwd = context.cwd ?? process.cwd();
+                return {
+                    schemaVersion: 1,
+                    sessionId: normalized,
+                    title: basename(cwd) || normalized,
+                    cwd,
+                    model: "",
+                    subModel: "",
+                    effort: "",
+                    createdAt: new Date(context.createdAt).toISOString(),
+                    updatedAt: new Date(context.updatedAt).toISOString(),
+                    approvals: [],
+                };
+            }
+            return null;
+        }
+    }
+    async list() {
+        let entries;
+        try {
+            entries = await readdir(this.rootDir);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                return [];
+            throw err;
+        }
+        const sessions = await Promise.all(entries.map((entry) => this.get(entry)));
+        return sessions
+            .filter((session) => session !== null)
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt) || a.sessionId.localeCompare(b.sessionId));
+    }
+    async update(sessionId, patch) {
+        const current = await this.require(sessionId);
+        const updated = {
+            ...current,
+            ...(patch.title !== undefined ? { title: cleanTitle(patch.title) || current.title } : {}),
+            ...(patch.model !== undefined ? { model: patch.model.trim() } : {}),
+            ...(patch.subModel !== undefined ? { subModel: patch.subModel.trim() } : {}),
+            ...(patch.effort !== undefined ? { effort: patch.effort.trim() } : {}),
+            updatedAt: this.now().toISOString(),
+        };
+        await this.save(updated);
+        return updated;
+    }
+    async delete(sessionId) {
+        const normalized = normalizeBuiltinSessionId(sessionId);
+        if (!await this.get(normalized))
+            return false;
+        await rm(join(this.rootDir, normalized), { recursive: true, force: true });
+        return true;
+    }
+    async addApproval(sessionId, approval) {
+        const meta = await this.require(sessionId);
+        await this.save({ ...meta, approvals: [...meta.approvals, approval].slice(-200), updatedAt: this.now().toISOString() });
+    }
+    async resolveApproval(sessionId, approvalId, answer) {
+        const meta = await this.require(sessionId);
+        const resolvedAt = this.now().toISOString();
+        await this.save({
+            ...meta,
+            updatedAt: resolvedAt,
+            approvals: meta.approvals.map((approval) => approval.approvalId === approvalId
+                ? { ...approval, status: "resolved", answer, resolvedAt }
+                : approval),
+        });
+    }
+    async require(sessionId) {
+        const meta = await this.get(sessionId);
+        if (!meta)
+            throw new Error(`DeepCCC web session not found: ${sessionId}`);
+        return meta;
+    }
+    async save(meta) {
+        const path = this.metaPath(meta.sessionId);
+        await mkdir(join(this.rootDir, meta.sessionId), { recursive: true });
+        const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+        await writeFile(tempPath, `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+        await rename(tempPath, path);
+    }
+    metaPath(sessionId) {
+        const normalized = normalizeBuiltinSessionId(sessionId);
+        return join(this.rootDir, normalized, "web.json");
+    }
+}
+function cleanCwd(value) {
+    if (typeof value !== "string" || !value.trim())
+        throw new Error("cwd must be a non-empty path");
+    return resolve(value.trim());
+}
+function cleanTitle(value) {
+    return value?.trim().slice(0, 120) ?? "";
+}
+function parseMeta(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid web session metadata");
+    const meta = value;
+    if (meta.schemaVersion !== 1)
+        throw new Error("Unsupported web session metadata");
+    for (const field of ["sessionId", "title", "cwd", "model", "subModel", "effort", "createdAt", "updatedAt"]) {
+        if (typeof meta[field] !== "string")
+            throw new Error(`Invalid web session ${field}`);
+    }
+    const approvals = Array.isArray(meta.approvals)
+        ? meta.approvals.filter(isApprovalRecord)
+        : [];
+    return { ...meta, approvals };
+}
+function isApprovalRecord(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const approval = value;
+    return typeof approval.approvalId === "string"
+        && typeof approval.tool === "string"
+        && typeof approval.action === "string"
+        && typeof approval.reason === "string"
+        && typeof approval.detail === "string"
+        && typeof approval.createdAt === "string"
+        && (approval.status === "pending" || approval.status === "resolved");
+}