deepccc 0.1.27 → 0.2.0

package/dist/web-server.js

@@ -0,0 +1,243 @@
+import { spawn } from "node:child_process";
+import { createServer } from "node:http";
+import { stat } from "node:fs/promises";
+import { loadConfig, saveConfigPatch, } from "./config.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;
+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" });
+            }
+            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 === "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 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 result = await options.runtime.sendMessage(decodeURIComponent(messagesMatch[1]), body.text ?? "");
+                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.openBrowser !== false)
+            openBrowser(url);
+        return defaultHandle;
+    }
+    if (await isExistingDeepCccServer(port)) {
+        const reused = { url, port, reused: true, close: async () => { } };
+        if (options.openBrowser !== false)
+            openBrowser(url);
+        return reused;
+    }
+    const runtime = new DeepCccWebRuntime({ loadConfig: runtimeConfig });
+    const defaultCwd = options.defaultCwd ?? process.cwd();
+    const handler = createDeepCccWebRequestHandler({
+        runtime,
+        defaultCwd,
+        getPublicConfig: () => toPublicConfig(loadConfig(), defaultCwd),
+        saveConfig: (patch) => toPublicConfig(saveConfigPatch(patch), defaultCwd),
+    });
+    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) => err ? reject(err) : resolve())),
+    };
+    defaultHandle = handle;
+    if (options.openBrowser ?? config.web.openOnStart)
+        openBrowser(url);
+    return handle;
+}
+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(); });
+}
+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 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);
+}
+class WebHttpError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.status = status;
+    }
+}
+async function isExistingDeepCccServer(port) {
+    try {
+        const response = await fetch(`http://${HOST}:${port}/api/health`, { signal: AbortSignal.timeout(800) });
+        return response.ok && (await response.json()).service === "deepccc-web";
+    }
+    catch {
+        return false;
+    }
+}
+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/web-session-store.d.ts

@@ -0,0 +1,43 @@
+export interface WebSessionMeta {
+    schemaVersion: 1;
+    sessionId: string;
+    title: string;
+    cwd: string;
+    model: string;
+    subModel: string;
+    effort: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CreateWebSessionInput {
+    cwd: string;
+    title?: string;
+    model?: string;
+    subModel?: string;
+    effort?: string;
+}
+export interface UpdateWebSessionInput {
+    title?: string;
+    model?: string;
+    subModel?: string;
+    effort?: string;
+}
+export interface WebSessionStoreOptions {
+    rootDir?: string;
+    now?: () => Date;
+    idFactory?: () => string;
+}
+export declare class WebSessionStore {
+    readonly rootDir: string;
+    private readonly now;
+    private readonly idFactory;
+    constructor(options?: WebSessionStoreOptions);
+    create(input: CreateWebSessionInput): Promise<WebSessionMeta>;
+    get(sessionId: string): Promise<WebSessionMeta | null>;
+    list(): Promise<WebSessionMeta[]>;
+    update(sessionId: string, patch: UpdateWebSessionInput): Promise<WebSessionMeta>;
+    delete(sessionId: string): Promise<boolean>;
+    private require;
+    private save;
+    private metaPath;
+}

package/dist/web-session-store.js

@@ -0,0 +1,130 @@
+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,
+        };
+        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(),
+                };
+            }
+            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 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}`);
+    }
+    return meta;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deepccc",
-  "version": "0.1.27",
+  "version": "0.2.0",
   "description": "A lightweight coding agent with OpenAI-compatible and Anthropic Messages API support.",
   "license": "Apache-2.0",
   "keywords": [