feishu-codex-console 1.0.0-beta.6

package/dist/conversation-turn-session.js

@@ -0,0 +1,209 @@
+import { applyCodexEvent, cancelTask, failTask, interruptTask, noteSteer, recoverTask, startTask, succeedTask, updateTaskCollaboration, updateQueuePosition, } from "./progress.js";
+import { prepareRemoteMarkdown, redactSensitiveText } from "./redaction.js";
+import { runningActivity, taskModeOf } from "./task-intent.js";
+// Feishu allows at most 20 edits for one text/post message. Keep ordinary
+// answers progressive without exhausting the edit budget before the final
+// response can replace the working state.
+const STREAM_THROTTLE_MS = 1_800;
+const MAX_PROGRESS_EDITS = 18;
+const MAX_MESSAGE_EDITS = 20;
+export class ConversationTurnSession {
+    lark;
+    messageId;
+    current;
+    sequence;
+    operationChain = Promise.resolve();
+    pendingContent = "";
+    lastContent = "";
+    streamTimer = null;
+    snapshotListener;
+    constructor(lark, messageId, current, sequence = 0) {
+        this.lark = lark;
+        this.messageId = messageId;
+        this.current = current;
+        this.sequence = sequence;
+        this.lastContent = renderConversationTurn(current);
+    }
+    static async create(lark, progress, replyToMessageId, idempotencyKey, replyInThread = false) {
+        const content = renderConversationTurn(progress);
+        const messageId = await lark.replyMarkdown(replyToMessageId, content, idempotencyKey, replyInThread);
+        if (!messageId)
+            throw new Error("飞书没有返回自然回复消息 ID");
+        return new ConversationTurnSession(lark, messageId, progress);
+    }
+    static restore(lark, messageId, progress, sequence = 0) {
+        return new ConversationTurnSession(lark, messageId, progress, sequence);
+    }
+    get progress() {
+        return this.current;
+    }
+    get sequenceNumber() {
+        return this.sequence;
+    }
+    onSnapshot(listener) {
+        this.snapshotListener = listener;
+    }
+    async markRunning(reviewBaseline, permissionLabel) {
+        this.current = startTask(this.current, Date.now(), reviewBaseline, permissionLabel);
+        await this.update("start");
+    }
+    async markRecovered(note, queuePosition = 1) {
+        this.current = recoverTask(this.current, queuePosition, note);
+        await this.update("recover");
+    }
+    async updateQueuePosition(queuePosition) {
+        const next = updateQueuePosition(this.current, queuePosition);
+        if (next === this.current)
+            return;
+        this.current = next;
+        await this.update("queue-position");
+    }
+    async markSteered() {
+        this.current = noteSteer(this.current);
+        await this.update("steer");
+    }
+    async addActionNote(note) {
+        this.current = { ...this.current, actionNote: note };
+        await this.update("note");
+    }
+    async updateCollaboration(context, note) {
+        this.current = updateTaskCollaboration(this.current, context, note);
+        await this.update("collaboration");
+    }
+    handleCodexEvent(event) {
+        this.current = { ...applyCodexEvent(this.current, event), actionNote: "" };
+        this.scheduleUpdate(renderConversationTurn(this.current));
+    }
+    async finishSucceeded(finalResponse, usage, threadId) {
+        this.current = succeedTask(this.current, finalResponse, usage, threadId);
+        return this.update("complete");
+    }
+    async finishFailed(error) {
+        this.current = failTask(this.current, error);
+        return this.update("fail");
+    }
+    async finishCancelled(reason) {
+        if (this.current.phase === "cancelled")
+            return true;
+        this.current = cancelTask(this.current, reason);
+        return this.update("cancel");
+    }
+    async finishInterrupted(reason) {
+        this.current = interruptTask(this.current, reason);
+        return this.update("interrupt");
+    }
+    async flush() {
+        await this.flushPendingUpdate();
+        await this.operationChain;
+    }
+    scheduleUpdate(content) {
+        this.pendingContent = content;
+        if (this.streamTimer)
+            return;
+        this.streamTimer = setTimeout(() => {
+            this.streamTimer = null;
+            void this.flushPendingUpdate();
+        }, STREAM_THROTTLE_MS);
+        this.streamTimer.unref();
+    }
+    async flushPendingUpdate() {
+        if (this.streamTimer) {
+            clearTimeout(this.streamTimer);
+            this.streamTimer = null;
+        }
+        const content = this.pendingContent;
+        this.pendingContent = "";
+        if (!content || content === this.lastContent)
+            return;
+        try {
+            await this.enqueue("stream", content);
+        }
+        catch {
+            // A later terminal update or the durable fallback will retry delivery.
+        }
+    }
+    async update(label) {
+        await this.flushPendingUpdate();
+        const content = renderConversationTurn(this.current);
+        if (content === this.lastContent) {
+            await this.notifySnapshot();
+            return true;
+        }
+        try {
+            await this.enqueue(label, content, isTerminalPhase(this.current.phase));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async enqueue(label, content, terminal = false) {
+        const next = this.operationChain.then(async () => {
+            if (!terminal && this.sequence >= MAX_PROGRESS_EDITS)
+                return;
+            if (terminal && this.sequence >= MAX_MESSAGE_EDITS) {
+                throw new Error("飞书消息已达到最大可编辑次数");
+            }
+            await this.lark.updateMarkdown(this.messageId, content);
+            this.sequence += 1;
+            this.lastContent = content;
+            await this.notifySnapshot();
+        });
+        this.operationChain = next.catch((error) => {
+            console.error(`[conversation] ${label} update failed message=${this.messageId}`, error);
+        });
+        await next;
+    }
+    async notifySnapshot() {
+        await this.snapshotListener?.({
+            messageId: this.messageId,
+            sequence: this.sequence,
+            progress: this.current,
+        });
+    }
+}
+function isTerminalPhase(phase) {
+    return phase === "succeeded" ||
+        phase === "failed" ||
+        phase === "cancelled" ||
+        phase === "interrupted";
+}
+export function renderConversationTurn(progress) {
+    if (progress.phase === "succeeded") {
+        return safeMarkdown(progress.finalResponse || progress.partialResponse || "Codex 已完成。");
+    }
+    if (progress.phase === "failed") {
+        return `**这次没有完成**\n\n${safeMarkdown(progress.error || "Codex 执行失败，请稍后重试。")}`;
+    }
+    if (progress.phase === "cancelled") {
+        return `**已停止**\n\n${safeMarkdown(progress.error || "当前处理已由用户停止。")}`;
+    }
+    if (progress.phase === "interrupted") {
+        return `**会话被中断**\n\n${safeMarkdown(progress.error || "本地服务中断了这次处理。")}`;
+    }
+    if (progress.phase === "queued") {
+        const queue = progress.queuePosition > 1
+            ? ` · 队列第 ${progress.queuePosition} 位`
+            : "";
+        return `已收到 · 正在准备${queue}`;
+    }
+    if (progress.actionNote.trim()) {
+        return safeInline(progress.actionNote);
+    }
+    if (progress.partialResponse.trim()) {
+        return `${safeMarkdown(progress.partialResponse)}\n\n正在继续生成…`;
+    }
+    const activity = progress.activity || runningActivity(taskModeOf(progress));
+    return `${safeInline(activity)}…`;
+}
+function safeMarkdown(value) {
+    return prepareRemoteMarkdown(redactSensitiveText(value, 12_000))
+        .replaceAll("<at", "＜at")
+        .replaceAll("</at>", "＜/at＞")
+        .replaceAll("<person", "＜person")
+        .replaceAll("</person>", "＜/person＞")
+        .trim();
+}
+function safeInline(value) {
+    return safeMarkdown(value).replace(/[*_`>#\[\]()]/g, "").replace(/\s+/g, " ").trim();
+}

package/dist/data-maintenance.js

@@ -0,0 +1,71 @@
+import "dotenv/config";
+import { loadConfig } from "./config.js";
+import { safeErrorText } from "./redaction.js";
+import { createRuntimeBackup, listRuntimeBackups, restoreRuntimeBackup, } from "./state-backup.js";
+async function main() {
+    const action = process.argv[2] ?? "list";
+    const options = parseOptions(process.argv.slice(3));
+    const config = loadConfig();
+    if (action === "backup") {
+        const snapshot = await createRuntimeBackup(config.databaseFile, {
+            reason: options.reason ?? "manual",
+        });
+        console.log("运行数据备份完成");
+        console.log(`备份 ID：${snapshot.id}`);
+        console.log(`位置：${snapshot.directory}`);
+        console.log(`校验：SHA-256 ${snapshot.manifest.database.sha256}`);
+        return;
+    }
+    if (action === "list") {
+        const backups = await listRuntimeBackups(config.databaseFile);
+        console.log(`可用运行数据备份（${backups.length}）`);
+        for (const snapshot of backups) {
+            console.log(`${snapshot.id} · ${snapshot.manifest.reason} · ${snapshot.manifest.database.bytes} bytes · schema ${snapshot.manifest.database.sqliteUserVersion}`);
+        }
+        if (backups.length === 0)
+            console.log("暂无备份。先运行 feishu-codex-bridge backup。");
+        return;
+    }
+    if (action === "rollback") {
+        if (!options.backup)
+            throw new Error("rollback 需要 --backup <备份 ID>");
+        if (!options.yes) {
+            throw new Error("回滚会替换当前运行数据库；确认服务已停止后，添加 --yes 执行");
+        }
+        const result = await restoreRuntimeBackup(config.databaseFile, config.dataDir, options.backup);
+        console.log(`已恢复备份：${result.restored.id}`);
+        if (result.safetyBackup) {
+            console.log(`回滚前状态已另存为：${result.safetyBackup.id}`);
+        }
+        console.log("下一步：启动服务并运行 doctor，确认状态和连接正常。");
+        return;
+    }
+    throw new Error(`未知数据维护命令：${action}`);
+}
+function parseOptions(args) {
+    const options = { yes: false };
+    for (let index = 0; index < args.length; index += 1) {
+        const value = args[index];
+        if (value === "--yes") {
+            options.yes = true;
+            continue;
+        }
+        if (value === "--backup" || value === "--reason") {
+            const next = args[index + 1];
+            if (!next || next.startsWith("--"))
+                throw new Error(`${value} 缺少值`);
+            if (value === "--backup")
+                options.backup = next;
+            else
+                options.reason = next;
+            index += 1;
+            continue;
+        }
+        throw new Error(`无法识别数据维护参数：${value}`);
+    }
+    return options;
+}
+void main().catch((error) => {
+    console.error(`数据维护失败：${safeErrorText(error)}`);
+    process.exitCode = 1;
+});