feishu-codex-console 1.0.0-beta.6

package/dist/card-session.js

@@ -0,0 +1,166 @@
+import { applyCodexEvent, attachTaskReview, cancelTask, failTask, interruptTask, noteSteer, noteTask, recoverTask, startTask, succeedTask, updateQueuePosition, updateTaskCollaboration, } from "./progress.js";
+import { renderStreamContent, renderTaskCard, } from "./task-card.js";
+const STREAM_THROTTLE_MS = 700;
+export class TaskCardSession {
+    lark;
+    cardId;
+    messageId;
+    current;
+    sequence = 0;
+    operationChain = Promise.resolve();
+    pendingContent = "";
+    lastContent = "";
+    streamTimer = null;
+    snapshotListener;
+    constructor(lark, cardId, messageId, current, sequence = 0) {
+        this.lark = lark;
+        this.cardId = cardId;
+        this.messageId = messageId;
+        this.current = current;
+        this.sequence = sequence;
+        this.lastContent = renderStreamContent(current);
+    }
+    static async create(lark, progress, replyToMessageId, idempotencyKey, replyInThread = false) {
+        const cardId = await lark.createCard(renderTaskCard(progress));
+        const messageId = await lark.replyCard(replyToMessageId, cardId, idempotencyKey, replyInThread);
+        return new TaskCardSession(lark, cardId, messageId ?? "", progress);
+    }
+    static restore(lark, cardId, messageId, progress, sequence) {
+        return new TaskCardSession(lark, cardId, 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.updateFullCard("start");
+    }
+    async markRecovered(note, queuePosition = 1) {
+        this.current = recoverTask(this.current, queuePosition, note);
+        await this.updateFullCard("recover");
+    }
+    async updateQueuePosition(queuePosition) {
+        const next = updateQueuePosition(this.current, queuePosition);
+        if (next === this.current)
+            return;
+        this.current = next;
+        await this.updateFullCard("queue-position");
+    }
+    async markSteered() {
+        this.current = noteSteer(this.current);
+        await this.updateFullCard("steer");
+    }
+    handleCodexEvent(event) {
+        this.current = applyCodexEvent(this.current, event);
+        this.scheduleStream(renderStreamContent(this.current));
+    }
+    async finishSucceeded(finalResponse, usage, threadId) {
+        this.current = succeedTask(this.current, finalResponse, usage, threadId);
+        return this.updateFullCard("complete");
+    }
+    async finishFailed(error) {
+        this.current = failTask(this.current, error);
+        return this.updateFullCard("fail");
+    }
+    async finishCancelled(reason) {
+        if (this.current.phase === "cancelled")
+            return true;
+        this.current = cancelTask(this.current, reason);
+        return this.updateFullCard("cancel");
+    }
+    async finishInterrupted(reason) {
+        this.current = interruptTask(this.current, reason);
+        return this.updateFullCard("interrupt");
+    }
+    async addActionNote(note) {
+        this.current = noteTask(this.current, note);
+        await this.updateFullCard("note");
+    }
+    async updateCollaboration(context, note) {
+        this.current = updateTaskCollaboration(this.current, context, note);
+        await this.updateFullCard("collaboration");
+    }
+    async attachReview(review) {
+        this.current = attachTaskReview(this.current, review);
+        await this.updateFullCard("review");
+    }
+    async showSurface(card, label = "surface") {
+        await this.flushStream();
+        return this.enqueue(label, async () => {
+            this.sequence += 1;
+            await this.lark.updateCard(this.cardId, card, this.sequence);
+            await this.notifySnapshot();
+        });
+    }
+    async restoreTaskSurface() {
+        return this.updateFullCard("restore-task");
+    }
+    async flush() {
+        await this.flushStream();
+        await this.operationChain;
+    }
+    scheduleStream(content) {
+        this.pendingContent = content;
+        if (this.streamTimer)
+            return;
+        this.streamTimer = setTimeout(() => {
+            this.streamTimer = null;
+            void this.flushStream();
+        }, STREAM_THROTTLE_MS);
+        this.streamTimer.unref();
+    }
+    async flushStream() {
+        if (this.streamTimer) {
+            clearTimeout(this.streamTimer);
+            this.streamTimer = null;
+        }
+        const content = this.pendingContent;
+        this.pendingContent = "";
+        if (!content || content === this.lastContent)
+            return;
+        await this.enqueue("stream", async () => {
+            this.sequence += 1;
+            await this.lark.streamCardContent(this.cardId, "stream_text", content, this.sequence);
+            this.lastContent = content;
+            await this.notifySnapshot();
+        });
+    }
+    async updateFullCard(label) {
+        await this.flushStream();
+        const card = renderTaskCard(this.current);
+        const content = renderStreamContent(this.current);
+        return this.enqueue(label, async () => {
+            this.sequence += 1;
+            await this.lark.updateCard(this.cardId, card, this.sequence);
+            this.lastContent = content;
+            await this.notifySnapshot();
+        });
+    }
+    async enqueue(label, operation) {
+        const next = this.operationChain.then(operation);
+        this.operationChain = next.catch((error) => {
+            console.error(`[card] ${label} update failed card=${this.cardId}`, error);
+        });
+        try {
+            await next;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async notifySnapshot() {
+        await this.snapshotListener?.({
+            cardId: this.cardId,
+            messageId: this.messageId,
+            sequence: this.sequence,
+            progress: this.current,
+        });
+    }
+}

package/dist/codex-events.js

@@ -0,0 +1 @@
+export {};