@kobinflow/canvas-agent 0.6.0

package/dist/agent/codex-event-history.d.ts

@@ -0,0 +1,21 @@
+import type { CodexSupplementalHistory, CodexSupplementalHistoryItem, CodexSupplementalHistoryTurn } from "./codex-history.js";
+export declare const CODEX_EVENT_HISTORY_FILE: string;
+/** 保存 Codex 持久线程投影可能省略的实时完成事件。 */
+export declare class CodexEventHistory {
+    private file;
+    private data?;
+    private queue;
+    constructor(file?: string);
+    /** 按 threadId、turnId 和 itemId 新增或更新一条补充事件。 */
+    record(entry: CodexSupplementalHistoryItem): Promise<void>;
+    /** 保存 turn 终态，使标准线程历史尚未物化时仍可恢复完整轮次。 */
+    recordTurn(entry: CodexSupplementalHistoryTurn): Promise<void>;
+    /** 按 item 开始顺序返回指定线程的补充事件。 */
+    readThread(threadId: string): Promise<CodexSupplementalHistory>;
+    /** 归档线程后删除其补充事件。 */
+    removeThread(threadId: string): Promise<void>;
+    private run;
+    private load;
+    private save;
+}
+export declare const codexEventHistory: CodexEventHistory;

package/dist/agent/codex-event-history.js

@@ -0,0 +1,163 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { CONFIG_DIR } from "../config.js";
+const MAX_ITEMS = 5000;
+const MAX_STRING_LENGTH = 100_000;
+export const CODEX_EVENT_HISTORY_FILE = path.join(CONFIG_DIR, "codex-event-history.json");
+/** 保存 Codex 持久线程投影可能省略的实时完成事件。 */
+export class CodexEventHistory {
+    file;
+    data;
+    queue = Promise.resolve();
+    constructor(file = CODEX_EVENT_HISTORY_FILE) {
+        this.file = file;
+    }
+    /** 按 threadId、turnId 和 itemId 新增或更新一条补充事件。 */
+    record(entry) {
+        return this.run(async () => {
+            const data = await this.load();
+            const index = data.items.findIndex((item) => sameItem(item, entry));
+            const previous = index >= 0 ? data.items[index] : undefined;
+            const nextEntry = normalizeEntry({
+                ...entry,
+                ...(entry.sequence === undefined && previous?.sequence !== undefined ? { sequence: previous.sequence } : {}),
+                item: mergeRecord(previous?.item, entry.item),
+            });
+            const items = [...data.items];
+            if (index >= 0)
+                items[index] = nextEntry;
+            else
+                items.push(nextEntry);
+            const nextData = { ...data, items: items.slice(-MAX_ITEMS) };
+            await this.save(nextData);
+            this.data = nextData;
+        });
+    }
+    /** 保存 turn 终态，使标准线程历史尚未物化时仍可恢复完整轮次。 */
+    recordTurn(entry) {
+        return this.run(async () => {
+            const data = await this.load();
+            const index = data.turns.findIndex((turn) => sameTurn(turn, entry));
+            const previous = index >= 0 ? data.turns[index] : undefined;
+            const nextEntry = normalizeTurn({ ...entry, turn: mergeRecord(previous?.turn, entry.turn) });
+            const turns = [...data.turns];
+            if (index >= 0)
+                turns[index] = nextEntry;
+            else
+                turns.push(nextEntry);
+            const nextData = { ...data, turns: turns.slice(-MAX_ITEMS) };
+            await this.save(nextData);
+            this.data = nextData;
+        });
+    }
+    /** 按 item 开始顺序返回指定线程的补充事件。 */
+    readThread(threadId) {
+        return this.run(async () => {
+            const data = await this.load();
+            return {
+                items: data.items.filter((item) => item.threadId === threadId).sort(compareEntries).map(cloneEntry),
+                turns: data.turns.filter((turn) => turn.threadId === threadId).map(cloneTurn),
+            };
+        });
+    }
+    /** 归档线程后删除其补充事件。 */
+    removeThread(threadId) {
+        return this.run(async () => {
+            const data = await this.load();
+            const items = data.items.filter((item) => item.threadId !== threadId);
+            const turns = data.turns.filter((turn) => turn.threadId !== threadId);
+            if (items.length === data.items.length && turns.length === data.turns.length)
+                return;
+            const nextData = { version: 1, items, turns };
+            await this.save(nextData);
+            this.data = nextData;
+        });
+    }
+    run(task) {
+        const result = this.queue.then(task, task);
+        this.queue = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async load() {
+        if (this.data)
+            return this.data;
+        try {
+            const value = JSON.parse(await fs.readFile(this.file, "utf8"));
+            this.data = value.version === 1 && Array.isArray(value.items) && Array.isArray(value.turns) ? { version: 1, items: value.items.map(normalizeEntry), turns: value.turns.map(normalizeTurn) } : emptyHistory();
+        }
+        catch (error) {
+            if (error.code !== "ENOENT" && !(error instanceof SyntaxError))
+                throw error;
+            this.data = emptyHistory();
+        }
+        return this.data;
+    }
+    async save(data) {
+        await fs.mkdir(path.dirname(this.file), { recursive: true });
+        const temporaryFile = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+        try {
+            await fs.writeFile(temporaryFile, JSON.stringify(data, null, 2));
+            await fs.rename(temporaryFile, this.file);
+        }
+        finally {
+            await fs.unlink(temporaryFile).catch(() => undefined);
+        }
+    }
+}
+export const codexEventHistory = new CodexEventHistory();
+function emptyHistory() {
+    return { version: 1, items: [], turns: [] };
+}
+function sameItem(left, right) {
+    return left.threadId === right.threadId && left.turnId === right.turnId && left.itemId === right.itemId;
+}
+function sameTurn(left, right) {
+    return left.threadId === right.threadId && left.turnId === right.turnId;
+}
+function cloneEntry(entry) {
+    return structuredClone(entry);
+}
+function cloneTurn(entry) {
+    return structuredClone(entry);
+}
+function compareEntries(left, right) {
+    if (left.sequence !== undefined && right.sequence !== undefined && left.sequence !== right.sequence)
+        return left.sequence - right.sequence;
+    if (left.sequence !== undefined)
+        return -1;
+    if (right.sequence !== undefined)
+        return 1;
+    return 0;
+}
+function normalizeEntry(entry) {
+    return {
+        ...entry,
+        ...(entry.sequence === undefined ? {} : { sequence: entry.sequence }),
+        item: truncateRecord(entry.item),
+    };
+}
+function normalizeTurn(entry) {
+    return { ...entry, turn: truncateRecord({ ...entry.turn, id: entry.turnId }) };
+}
+function mergeRecord(previous, next) {
+    if (!previous)
+        return next;
+    const merged = { ...previous };
+    Object.entries(next).forEach(([key, value]) => {
+        if (value !== undefined)
+            merged[key] = value;
+    });
+    return merged;
+}
+function truncateRecord(value) {
+    return truncateValue(value);
+}
+function truncateValue(value) {
+    if (typeof value === "string")
+        return value.length > MAX_STRING_LENGTH ? `${value.slice(0, MAX_STRING_LENGTH)}\n[输出已截断]` : value;
+    if (Array.isArray(value))
+        return value.map(truncateValue);
+    if (value && typeof value === "object")
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, truncateValue(item)]));
+    return value;
+}

package/dist/agent/codex-history.d.ts

@@ -0,0 +1,46 @@
+import type { CodexPlanUpdate } from "./codex-protocol.js";
+type AgentHistoryMessage = {
+    id: string;
+    itemId: string;
+    threadId: string;
+    turnId: string;
+    role: "user" | "assistant" | "tool" | "error";
+    title?: string;
+    text: string;
+    detail?: unknown;
+    activityItems?: Record<string, string>;
+};
+export type CodexSupplementalHistoryItem = {
+    threadId: string;
+    turnId: string;
+    itemId: string;
+    sequence?: number;
+    item: Record<string, unknown>;
+};
+export type CodexSupplementalHistoryTurn = {
+    threadId: string;
+    turnId: string;
+    turn: Record<string, unknown>;
+};
+export type CodexSupplementalHistory = {
+    items: CodexSupplementalHistoryItem[];
+    turns: CodexSupplementalHistoryTurn[];
+};
+/** 将 Codex 线程转换为列表展示所需的摘要。 */
+export declare function summarizeCodexThread(thread: unknown): {
+    id: string;
+    sessionId: string;
+    preview: string;
+    name: string | null;
+    cwd: string;
+    status: string;
+    source: unknown;
+    threadSource: unknown;
+    createdAt: number;
+    updatedAt: number;
+};
+/** 返回已经终结、可由持久化历史作为权威内容的 turn。 */
+export declare function settledTurnIds(thread: unknown, supplementalHistory?: CodexSupplementalHistory): string[];
+/** 将 Codex turn items 转换为网页聊天历史。 */
+export declare function threadMessages(thread: unknown, planUpdates?: CodexPlanUpdate[], supplementalHistory?: CodexSupplementalHistory): AgentHistoryMessage[];
+export {};