chatccc 0.2.270 → 0.2.276

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

@@ -0,0 +1,331 @@
+import { randomUUID } from "node:crypto";
+import { readFile, realpath, stat } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { AttachmentStore, buildAttachmentPrompt, detectImageMime, MAX_ATTACHMENTS_PER_MESSAGE, MAX_ATTACHMENT_BYTES, } from "./attachments.js";
+import { ChatSession } from "./index.js";
+import { DEFAULT_BUILTIN_CONTEXT_DIR, normalizeBuiltinSessionId, readBuiltinContextState } from "./context.js";
+import { WebSessionStore, } from "./web-session-store.js";
+export class DeepCccWebRuntime {
+    store;
+    attachmentStore;
+    loadConfig;
+    sessionFactory;
+    approvalTimeoutMs;
+    now;
+    idFactory;
+    agents = new Map();
+    activeRuns = new Map();
+    startingRuns = new Map();
+    sessionMutations = new Set();
+    events = new Map();
+    listeners = new Map();
+    globalListeners = new Set();
+    approvals = new Map();
+    nextEventId = 1;
+    constructor(options) {
+        this.store = options.store ?? new WebSessionStore();
+        this.attachmentStore = options.attachmentStore ?? new AttachmentStore(resolve(this.store.rootDir) === resolve(DEFAULT_BUILTIN_CONTEXT_DIR)
+            ? {}
+            : { rootDir: join(this.store.rootDir, ".attachments") });
+        this.loadConfig = options.loadConfig;
+        this.approvalTimeoutMs = options.approvalTimeoutMs ?? 5 * 60_000;
+        this.now = options.now ?? (() => new Date());
+        this.idFactory = options.idFactory ?? randomUUID;
+        this.sessionFactory = options.sessionFactory ?? ((input) => new ChatSession({
+            provider: input.config.provider,
+            apiKey: input.config.apiKey,
+            baseURL: input.config.baseURL,
+            model: input.meta.model || input.config.model,
+            subModel: input.meta.subModel || input.config.subModel,
+            effort: input.meta.effort || input.config.effort,
+            maxOutputTokens: input.config.maxOutputTokens,
+            streaming: input.config.streaming,
+        }, {
+            cwd: input.meta.cwd,
+            persist: true,
+            sessionId: input.meta.sessionId,
+            contextWindow: input.config.contextWindow,
+            permissionMode: "ask",
+            permissionResolver: input.permissionResolver,
+        }));
+    }
+    async listSessions() {
+        const sessions = await this.store.list();
+        return sessions.map((meta) => ({ ...meta, status: this.activeRuns.has(meta.sessionId) ? "running" : "idle" }));
+    }
+    async createSession(input) {
+        const config = this.loadConfig();
+        const session = await this.store.create({
+            ...input,
+            model: input.model ?? config.model,
+            subModel: input.subModel ?? config.subModel,
+            effort: input.effort ?? config.effort,
+        });
+        this.emit(session.sessionId, "session_updated", session);
+        return session;
+    }
+    async getSession(sessionId) {
+        const meta = await this.requireSession(sessionId);
+        const context = readBuiltinContextState(sessionId, this.store.rootDir);
+        const pendingApproval = [...this.approvals.values()].find((entry) => entry.approval.sessionId === sessionId)?.approval ?? null;
+        return {
+            ...meta,
+            status: this.activeRuns.has(sessionId) ? "running" : "idle",
+            runId: this.activeRuns.get(sessionId)?.runId ?? null,
+            messages: context?.messages ?? [],
+            summary: context?.summary ?? "",
+            events: this.events.get(sessionId) ?? [],
+            pendingApproval,
+            approvals: meta.approvals,
+        };
+    }
+    async updateSession(sessionId, patch) {
+        if (this.activeRuns.has(sessionId) || this.startingRuns.has(sessionId) || this.sessionMutations.has(sessionId)) {
+            throw new Error("Cannot change session settings while another session operation is running");
+        }
+        this.sessionMutations.add(sessionId);
+        try {
+            const updated = await this.store.update(sessionId, patch);
+            this.agents.delete(sessionId);
+            this.emit(sessionId, "session_updated", updated);
+            return updated;
+        }
+        finally {
+            this.sessionMutations.delete(sessionId);
+        }
+    }
+    async deleteSession(sessionId) {
+        if (this.activeRuns.has(sessionId) || this.startingRuns.has(sessionId) || this.sessionMutations.has(sessionId)) {
+            throw new Error("Stop the running session before deleting it");
+        }
+        this.sessionMutations.add(sessionId);
+        try {
+            this.agents.delete(sessionId);
+            const deleted = await this.store.delete(sessionId);
+            if (deleted) {
+                await this.attachmentStore.deleteSession(sessionId);
+                this.emit(sessionId, "session_deleted", { sessionId });
+                this.events.delete(sessionId);
+            }
+            return deleted;
+        }
+        finally {
+            this.sessionMutations.delete(sessionId);
+        }
+    }
+    async sendMessage(sessionId, text, attachmentIds = []) {
+        const displayPrompt = text.trim();
+        const uniqueAttachmentIds = [...new Set(attachmentIds)];
+        if (uniqueAttachmentIds.length > MAX_ATTACHMENTS_PER_MESSAGE) {
+            throw new Error(`A message can include at most ${MAX_ATTACHMENTS_PER_MESSAGE} images`);
+        }
+        if (!displayPrompt && !uniqueAttachmentIds.length)
+            throw new Error("Message must not be empty");
+        const controller = new AbortController();
+        if (this.activeRuns.has(sessionId) || this.startingRuns.has(sessionId) || this.sessionMutations.has(sessionId)) {
+            throw new Error("This session is already running");
+        }
+        this.startingRuns.set(sessionId, controller);
+        try {
+            let meta = await this.requireSession(sessionId);
+            const attachments = [];
+            for (const attachmentId of uniqueAttachmentIds) {
+                const attachment = await this.attachmentStore.get(sessionId, attachmentId);
+                if (!attachment)
+                    throw new Error(`Image attachment not found: ${attachmentId}`);
+                attachments.push(attachment);
+            }
+            const prompt = buildAttachmentPrompt(displayPrompt, attachments);
+            if (meta.title === "新会话" || meta.title === "New session" || meta.title === meta.cwd.split(/[\\/]/).at(-1)) {
+                const title = displayPrompt || attachments.map((attachment) => attachment.originalName).join(", ") || "图片任务";
+                meta = await this.store.update(sessionId, { title: title.replace(/\s+/g, " ").slice(0, 42) });
+            }
+            if (controller.signal.aborted)
+                throw new DOMException("The session start was stopped", "AbortError");
+            const runId = `run-${this.idFactory()}`;
+            this.events.set(sessionId, []);
+            this.emit(sessionId, "user", { text: displayPrompt || "请分析这些图片。", attachments });
+            const promise = Promise.resolve()
+                .then(() => this.run(meta, prompt, runId, controller.signal))
+                .finally(() => {
+                this.activeRuns.delete(sessionId);
+                this.emit(sessionId, "session_updated", { sessionId, status: "idle" });
+            });
+            this.activeRuns.set(sessionId, { runId, controller, promise });
+            this.emit(sessionId, "run_started", { runId });
+            void promise.catch(() => { });
+            return { runId };
+        }
+        finally {
+            this.startingRuns.delete(sessionId);
+        }
+    }
+    async stopSession(sessionId) {
+        const active = this.activeRuns.get(sessionId);
+        const starting = this.startingRuns.get(sessionId);
+        if (!active && !starting)
+            return false;
+        starting?.abort();
+        if (!active)
+            return true;
+        active.controller.abort();
+        const pending = [...this.approvals.entries()]
+            .filter(([, waiter]) => waiter.approval.sessionId === sessionId);
+        await Promise.all(pending.map(([approvalId, waiter]) => this.finishApproval(approvalId, waiter, "deny", { stopped: true }).catch(() => { })));
+        return true;
+    }
+    async addAttachment(sessionId, input) {
+        await this.requireSession(sessionId);
+        return this.attachmentStore.save(sessionId, input);
+    }
+    async readAttachment(sessionId, attachmentId) {
+        await this.requireSession(sessionId);
+        return this.attachmentStore.read(sessionId, attachmentId);
+    }
+    async deleteAttachment(sessionId, attachmentId) {
+        await this.requireSession(sessionId);
+        return this.attachmentStore.delete(sessionId, attachmentId);
+    }
+    async readArtifact(sessionId, value) {
+        const meta = await this.requireSession(sessionId);
+        const path = await realpath(resolve(value)).catch(() => null);
+        if (!path)
+            return null;
+        const workspaceRoot = await realpath(meta.cwd).catch(() => resolve(meta.cwd));
+        const attachmentDir = join(this.attachmentStore.rootDir, normalizeBuiltinSessionId(sessionId));
+        const attachmentRoot = await realpath(attachmentDir).catch(() => resolve(attachmentDir));
+        if (!isPathInside(workspaceRoot, path) && !isPathInside(attachmentRoot, path)) {
+            throw new Error("Artifact path is outside the session workspace and attachment directory");
+        }
+        const info = await stat(path).catch(() => null);
+        if (!info?.isFile())
+            return null;
+        if (info.size > MAX_ATTACHMENT_BYTES)
+            throw new Error("Artifact image exceeds the 20 MB limit");
+        const bytes = await readFile(path);
+        const mimeType = detectImageMime(bytes);
+        if (!mimeType)
+            throw new Error("Artifact is not a supported PNG, JPEG, or WebP image");
+        return { path, mimeType, size: bytes.length, bytes };
+    }
+    async waitForIdle(sessionId) {
+        await this.activeRuns.get(sessionId)?.promise;
+    }
+    async resolveApproval(approvalId, answer) {
+        const waiter = this.approvals.get(approvalId);
+        if (!waiter)
+            return false;
+        await this.finishApproval(approvalId, waiter, answer);
+        return true;
+    }
+    subscribe(sessionId, listener) {
+        const set = this.listeners.get(sessionId) ?? new Set();
+        set.add(listener);
+        this.listeners.set(sessionId, set);
+        return () => {
+            set.delete(listener);
+            if (!set.size)
+                this.listeners.delete(sessionId);
+        };
+    }
+    subscribeAll(listener) {
+        this.globalListeners.add(listener);
+        return () => this.globalListeners.delete(listener);
+    }
+    async run(meta, prompt, runId, signal) {
+        try {
+            const agent = this.agents.get(meta.sessionId) ?? this.createAgent(meta);
+            this.agents.set(meta.sessionId, agent);
+            for await (const event of agent.chat(prompt, signal))
+                this.emit(meta.sessionId, "agent", event);
+            this.emit(meta.sessionId, "run_finished", { runId, outcome: signal.aborted ? "stopped" : "done" });
+            await this.store.update(meta.sessionId, {});
+        }
+        catch (err) {
+            const stopped = signal.aborted || (err instanceof Error && err.name === "AbortError");
+            this.emit(meta.sessionId, "agent", { type: "error", message: stopped ? "已停止" : err.message });
+            this.emit(meta.sessionId, "run_finished", { runId, outcome: stopped ? "stopped" : "error" });
+        }
+    }
+    createAgent(meta) {
+        return this.sessionFactory({
+            meta,
+            config: this.loadConfig(),
+            permissionResolver: (request) => this.requestApproval(meta.sessionId, request),
+        });
+    }
+    requestApproval(sessionId, request) {
+        const approvalId = `approval-${this.idFactory()}`;
+        const approval = {
+            ...request,
+            approvalId,
+            sessionId,
+            createdAt: this.now().toISOString(),
+        };
+        return new Promise((resolve) => {
+            const ready = this.store.addApproval(sessionId, {
+                ...approval,
+                status: "pending",
+            });
+            let waiter;
+            const timeout = setTimeout(() => {
+                void this.finishApproval(approvalId, waiter, "deny", { timedOut: true }).catch(() => { });
+            }, this.approvalTimeoutMs);
+            timeout.unref?.();
+            waiter = { approval, resolve, timeout, ready };
+            this.approvals.set(approvalId, waiter);
+            void ready.then(() => {
+                if (this.approvals.get(approvalId) !== waiter)
+                    return;
+                this.emit(sessionId, "approval", approval);
+            }).catch(() => {
+                if (this.approvals.get(approvalId) !== waiter)
+                    return;
+                clearTimeout(timeout);
+                this.approvals.delete(approvalId);
+                resolve("deny");
+            });
+        });
+    }
+    async finishApproval(approvalId, waiter, answer, extra = {}) {
+        if (this.approvals.get(approvalId) !== waiter)
+            return;
+        clearTimeout(waiter.timeout);
+        this.approvals.delete(approvalId);
+        try {
+            await waiter.ready;
+            await this.store.resolveApproval(waiter.approval.sessionId, approvalId, answer);
+        }
+        finally {
+            waiter.resolve(answer);
+            this.emit(waiter.approval.sessionId, "approval_resolved", { approvalId, answer, ...extra });
+        }
+    }
+    emit(sessionId, type, data) {
+        const event = { eventId: this.nextEventId++, sessionId, at: this.now().toISOString(), type, data };
+        const events = [...(this.events.get(sessionId) ?? []), event].slice(-500);
+        this.events.set(sessionId, events);
+        this.notifyListeners(this.listeners.get(sessionId) ?? [], event);
+        if (["run_started", "run_finished", "session_updated", "session_deleted"].includes(type)) {
+            this.notifyListeners(this.globalListeners, event);
+        }
+    }
+    notifyListeners(listeners, event) {
+        for (const listener of listeners) {
+            try {
+                listener(event);
+            }
+            catch { /* a disconnected SSE client must not affect the Agent run */ }
+        }
+    }
+    async requireSession(sessionId) {
+        const meta = await this.store.get(sessionId);
+        if (!meta)
+            throw new Error(`DeepCCC web session not found: ${sessionId}`);
+        return meta;
+    }
+}
+function isPathInside(root, candidate) {
+    const rel = relative(resolve(root), resolve(candidate));
+    return rel === "" || (rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel));
+}