@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/channel-feishu/dist/session-watcher.js

@@ -0,0 +1,655 @@
+import { createChannelStreamProjector } from "@codebridge/router";
+import { runCardJson } from "./cardkit-writer.js";
+import { CoalescingCardWriter } from "./coalescing-card-writer.js";
+import { applyRunSnapshot, createFeishuRunStatus, finishFeishuRunStatus, recordFeishuRunActivity, recordRunVerificationFailure, renderFeishuRunStatus, setCoreEventStream, setHttpWrite, setInboundWebSocket, } from "./run-status.js";
+export const FEISHU_LIVE_STATUS_TICK_MS = 15_000;
+export { FEISHU_LIVE_STATUS_QUIET_MS } from "./run-status.js";
+const FEISHU_LIVE_PROGRESS_CHARS = 1200;
+export function classifyFeishuCardWriteError(error) {
+    const text = error instanceof Error ? error.message : String(error);
+    return /\b(?:11310|200740|200750|300311)\b|card\s*id\s*invalid|cardid\s*invalid/i.test(text)
+        ? "permanent"
+        : "transient";
+}
+function terminalStateForEvent(type) {
+    switch (type) {
+        case "RUN_SUCCEEDED":
+            return "succeeded";
+        case "RUN_FAILED":
+            return "failed";
+        case "RUN_CANCELLED":
+            return "cancelled";
+        case "RUN_INTERRUPTED":
+            return "interrupted";
+        default:
+            return undefined;
+    }
+}
+/** 一个 Run 的飞书流式卡片。开卡后由 watcher 喂 AgentEvent，终态时 finalize。 */
+export class FeishuRunCard {
+    host;
+    chatId;
+    sourceMessageId;
+    runId;
+    projector;
+    runStatus;
+    abortController;
+    cardDone;
+    cardDoneResolve;
+    readyResolve;
+    ready = new Promise((resolve) => { this.readyResolve = resolve; });
+    writer;
+    lastWriteError;
+    streamMessageId;
+    streamCardId;
+    queueRender = () => { };
+    done = false;
+    constructor(host, chatId, sourceMessageId, runId, showThinking) {
+        this.host = host;
+        this.chatId = chatId;
+        this.sourceMessageId = sourceMessageId;
+        this.runId = runId;
+        this.projector = createChannelStreamProjector({
+            showThinking,
+            maxProgressChars: FEISHU_LIVE_PROGRESS_CHARS,
+        });
+        this.runStatus = createFeishuRunStatus();
+        this.abortController = new AbortController();
+        this.cardDone = new Promise((resolve) => { this.cardDoneResolve = resolve; });
+    }
+    get signal() {
+        return this.abortController.signal;
+    }
+    get cardMessageId() {
+        return this.streamMessageId;
+    }
+    get cardInstanceId() {
+        return this.streamCardId;
+    }
+    async open() {
+        if (!this.host.channel)
+            return;
+        void this.host.channel.stream(this.chatId, {
+            markdown: async (s) => {
+                const cardId = s.cardId;
+                if (typeof cardId === "string" && cardId) {
+                    this.streamCardId = cardId;
+                }
+                this.streamMessageId = s.messageId;
+                this.host.registerPendingStream(s.messageId, {
+                    chatId: this.chatId,
+                    sourceMessageId: this.sourceMessageId,
+                    startedAt: new Date().toISOString(),
+                });
+                if (this.abortController.signal.aborted) {
+                    this.cardDoneResolve();
+                    return;
+                }
+                this.writer = new CoalescingCardWriter(async (snapshot) => {
+                    if (this.abortController.signal.aborted)
+                        return;
+                    try {
+                        if (s.setSnapshot)
+                            await s.setSnapshot(snapshot.parts);
+                        else
+                            await s.setContent(snapshot.content);
+                        this.lastWriteError = undefined;
+                        setHttpWrite(this.runStatus, "healthy");
+                    }
+                    catch (err) {
+                        const message = err instanceof Error ? err.message : String(err);
+                        setHttpWrite(this.runStatus, "degraded");
+                        if (snapshot.statusOnly) {
+                            this.host.log(`飞书任务状态刷新失败（不影响 Agent 运行）：${message}`);
+                            return;
+                        }
+                        this.lastWriteError = err;
+                        this.host.log(`飞书卡片内容写入失败，等待重放：${message}`);
+                        throw err;
+                    }
+                }, undefined, (pending, next) => ({
+                    ...next,
+                    statusOnly: pending.statusOnly && next.statusOnly,
+                }));
+                this.queueRender = (statusOnly) => {
+                    const status = renderFeishuRunStatus(this.runStatus);
+                    const snapshot = this.projector.snapshot();
+                    const agentText = this.runStatus.state === "running"
+                        ? snapshot.liveText
+                        : snapshot.finalText;
+                    const body = (agentText);
+                    this.writer?.enqueue({
+                        content: status && body ? `${body}\n\n---\n\n${status}` : body || status,
+                        parts: {
+                            answer: this.runStatus.state === "running" ? snapshot.result : agentText,
+                            progress: (this.runStatus.state === "running"
+                                ? [snapshot.thinking, snapshot.progress].filter(Boolean).join("\n\n") : ""),
+                            status,
+                            terminal: this.runStatus.state !== "running",
+                        },
+                        statusOnly,
+                    });
+                };
+                this.queueRender(false);
+                this.readyResolve();
+                await this.cardDone;
+            },
+        }, { replyTo: this.sourceMessageId }).catch((err) => {
+            this.host.log(`卡片建卡失败: ${err instanceof Error ? err.message : String(err)}`);
+            this.readyResolve();
+            this.cardDoneResolve();
+        });
+        await this.ready;
+    }
+    async onAgentEvent(event) {
+        await this.ready;
+        if (this.abortController.signal.aborted)
+            return;
+        const recorded = recordFeishuRunActivity(this.runStatus, event);
+        if (event.type === "permission_request") {
+            void this.host
+                .sendMarkdown(this.chatId, `🔐 Agent 请求权限：**${event.title}**`, this.sourceMessageId)
+                .catch(() => { });
+            if (recorded)
+                this.queueRender(true);
+            return;
+        }
+        const previous = this.projector.snapshot().liveText;
+        const next = this.projector.apply(event);
+        this.queueRender(previous === next.liveText);
+    }
+    async reconcileRun(snapshot, inboundState) {
+        await this.ready;
+        if (this.abortController.signal.aborted)
+            return;
+        setInboundWebSocket(this.runStatus, inboundState);
+        applyRunSnapshot(this.runStatus, snapshot);
+        this.queueRender(false);
+        await this.writer?.flush();
+        if (this.runStatus.state !== "running" && this.lastWriteError) {
+            throw this.lastWriteError;
+        }
+    }
+    async setCoreEventStreamState(state) {
+        await this.ready;
+        if (this.abortController.signal.aborted)
+            return;
+        setCoreEventStream(this.runStatus, state);
+        this.queueRender(true);
+        await this.writer?.flush();
+    }
+    async setInboundWebSocketState(state) {
+        await this.ready;
+        if (this.abortController.signal.aborted)
+            return;
+        setInboundWebSocket(this.runStatus, state);
+        this.queueRender(true);
+        await this.writer?.flush();
+    }
+    async finalize(terminalState) {
+        await this.ready;
+        if (this.done)
+            return;
+        finishFeishuRunStatus(this.runStatus, terminalState);
+        this.queueRender(false);
+        await this.writer?.flush();
+        if (this.lastWriteError)
+            throw this.lastWriteError;
+        this.done = true;
+        if (this.streamMessageId && !this.host.isDisconnecting()) {
+            this.host.clearPendingStream(this.streamMessageId);
+        }
+        this.cardDoneResolve();
+    }
+    abort() {
+        if (this.done)
+            return;
+        this.done = true;
+        this.abortController.abort();
+        this.cardDoneResolve();
+    }
+}
+function isTerminalRunSnapshot(snapshot) {
+    return snapshot !== null
+        && snapshot.status !== "queued"
+        && snapshot.status !== "running"
+        && snapshot.status !== "waiting";
+}
+/** 每 Session 一个持久 events 订阅，单订阅统一路由 Turn / Run / Delivery。 */
+export class FeishuSessionWatcher {
+    host;
+    ingress;
+    sessionId;
+    instanceId;
+    abortController = new AbortController();
+    afterSequence = 0;
+    started = false;
+    cards = new Map();
+    pendingTurns = new Map();
+    deliveries = new Map();
+    resumedCards = new Map();
+    fatalAgentErrorRuns = new Set();
+    permanentlyInvalidCardIds = new Set();
+    loggedPermanentCardIds = new Set();
+    constructor(host, ingress, sessionId, instanceId) {
+        this.host = host;
+        this.ingress = ingress;
+        this.sessionId = sessionId;
+        this.instanceId = instanceId;
+    }
+    /** 注入初始 cursor 后再启动，避免启动后登记 pending Turn/开卡前消费事件。 */
+    start(afterSequence) {
+        if (this.started)
+            return;
+        this.started = true;
+        this.afterSequence = afterSequence;
+        void this.run().catch((err) => {
+            this.host.log(`session watcher 退出: ${err instanceof Error ? err.message : String(err)}`);
+        });
+    }
+    registerPendingTurn(turnId, turn) {
+        this.pendingTurns.set(turnId, turn);
+    }
+    /** 恢复 delivering 状态：按 surfaceMessageId 重放事件投影最终回答，终态更新原卡片。 */
+    resumeCardForRun(runId, surfaceMessageId, turnId, owner, showThinking, surfaceCardId) {
+        const existing = this.resumedCards.get(runId);
+        if (existing) {
+            this.deliveries.set(runId, { turnId, owner });
+            return;
+        }
+        const runStatus = createFeishuRunStatus();
+        this.resumedCards.set(runId, {
+            surfaceMessageId,
+            surfaceCardId,
+            projector: createChannelStreamProjector({
+                showThinking,
+                maxProgressChars: FEISHU_LIVE_PROGRESS_CHARS,
+            }),
+            runStatus,
+            resultRecovery: "pending",
+            projectionReady: false,
+            pendingReplayEvents: [],
+            projectedSequences: new Set(),
+        });
+        this.deliveries.set(runId, { turnId, owner });
+    }
+    async reconcileDelivery(delivery, turn, inboundState) {
+        if (delivery.surfaceCardId &&
+            this.permanentlyInvalidCardIds.has(delivery.surfaceCardId)) {
+            return;
+        }
+        if (!delivery.runId) {
+            this.registerPendingTurn(delivery.turnId, turn);
+            return;
+        }
+        let card = this.cards.get(delivery.runId);
+        if (!delivery.surfaceMessageId) {
+            await this.openCardForRun(delivery.runId, turn);
+            card = this.cards.get(delivery.runId);
+        }
+        else if (!card) {
+            let surfaceCardId = delivery.surfaceCardId;
+            if (!surfaceCardId) {
+                try {
+                    if (!this.host.resolveCardId) {
+                        throw new Error("CardKit id resolver is unavailable");
+                    }
+                    surfaceCardId = await this.host.resolveCardId(delivery.surfaceMessageId);
+                    const persisted = await this.ingress.ackDelivery(delivery.turnId, delivery.claimOwner ?? "", delivery.surfaceMessageId, surfaceCardId);
+                    if (!persisted) {
+                        throw new Error("resolved CardKit id could not be persisted");
+                    }
+                }
+                catch (error) {
+                    this.host.log(JSON.stringify({
+                        event: "feishu_card_id_recovery_failed",
+                        channel: "feishu",
+                        sessionId: this.sessionId,
+                        runId: delivery.runId,
+                        surfaceMessageId: delivery.surfaceMessageId,
+                        message: error instanceof Error ? error.message : String(error),
+                    }));
+                    return;
+                }
+            }
+            this.resumeCardForRun(delivery.runId, delivery.surfaceMessageId, delivery.turnId, delivery.claimOwner ?? "", turn.showThinking, surfaceCardId);
+        }
+        if (card) {
+            try {
+                if (delivery.runSnapshot) {
+                    await card.reconcileRun(delivery.runSnapshot, inboundState);
+                }
+                else {
+                    await card.setInboundWebSocketState(inboundState);
+                }
+            }
+            catch (error) {
+                const messageId = card.cardMessageId;
+                if (messageId && this.recordPermanentCardFailure(delivery.runId, messageId, error)) {
+                    card.abort();
+                    this.cards.delete(delivery.runId);
+                    return;
+                }
+                throw error;
+            }
+        }
+        const resumed = card ? undefined : this.resumedCards.get(delivery.runId);
+        if (resumed) {
+            setInboundWebSocket(resumed.runStatus, inboundState);
+            const terminal = isTerminalRunSnapshot(delivery.runSnapshot);
+            if (terminal || !resumed.projectionReady) {
+                await this.restorePersistedResult(delivery, resumed);
+            }
+            if (delivery.runSnapshot) {
+                applyRunSnapshot(resumed.runStatus, delivery.runSnapshot);
+                if ((delivery.runSnapshot.status === "running" ||
+                    delivery.runSnapshot.status === "waiting") &&
+                    delivery.runSnapshot.sessionActiveRunId !== delivery.runId) {
+                    recordRunVerificationFailure(resumed.runStatus, "Run 与 Session activeRun 不一致");
+                }
+            }
+            const written = await this.writeResumedCard(delivery.runId, resumed);
+            if (terminal && resumed.resultRecovery === "confirmed" && written) {
+                await this.completeDeliveryForRun(delivery.runId);
+            }
+        }
+    }
+    async restorePersistedResult(delivery, resumed) {
+        if (resumed.resultRecovery === "confirmed")
+            return;
+        if (!delivery.runId || !this.ingress.replayEvents) {
+            this.logResultRecoveryFailure(delivery, "finite replay is unavailable");
+            return;
+        }
+        try {
+            const events = await this.ingress.replayEvents(delivery.sessionId, {
+                afterSequence: delivery.acceptedSequence,
+            });
+            this.finishProjectionReplay(delivery.runId, resumed, events);
+            if (!isTerminalRunSnapshot(delivery.runSnapshot))
+                return;
+            const expectedTerminalState = delivery.runSnapshot?.status;
+            const hasMatchingTerminalEvent = events.some((event) => event.runId === delivery.runId
+                && terminalStateForEvent(event.type) === expectedTerminalState);
+            if (!hasMatchingTerminalEvent) {
+                this.logResultRecoveryFailure(delivery, "matching terminal event is missing from finite replay");
+                return;
+            }
+            resumed.resultRecovery = "confirmed";
+        }
+        catch (error) {
+            this.logResultRecoveryFailure(delivery, error instanceof Error ? error.message : String(error));
+        }
+    }
+    finishProjectionReplay(runId, resumed, events) {
+        const ordered = [...events, ...resumed.pendingReplayEvents].sort((a, b) => a.sequence - b.sequence);
+        resumed.pendingReplayEvents = [];
+        resumed.projectionReady = true;
+        for (const event of ordered) {
+            this.applyRecoveredEvent(runId, resumed, event);
+            const terminal = event.runId === runId ? terminalStateForEvent(event.type) : undefined;
+            if (terminal) {
+                finishFeishuRunStatus(resumed.runStatus, terminal);
+                resumed.resultRecovery = "confirmed";
+            }
+        }
+    }
+    applyRecoveredEvent(runId, resumed, event) {
+        if (event.runId !== runId
+            || resumed.projectedSequences.has(event.sequence))
+            return;
+        if (!resumed.projectionReady) {
+            resumed.pendingReplayEvents.push(event);
+            return;
+        }
+        if (event.type === "AGENT_EVENT") {
+            const agentEvent = event.payload.event;
+            if (!agentEvent)
+                return;
+            if (agentEvent.type === "error" && agentEvent.fatal) {
+                this.fatalAgentErrorRuns.add(runId);
+            }
+            recordFeishuRunActivity(resumed.runStatus, agentEvent);
+            resumed.projector.apply(agentEvent);
+            resumed.projectedSequences.add(event.sequence);
+            return;
+        }
+        if (event.type === "STEP_FAILED" && !this.fatalAgentErrorRuns.has(runId)) {
+            resumed.projector.apply({
+                type: "error",
+                message: String(event.payload?.error ?? "Step failed"),
+            });
+        }
+        if (event.type === "STEP_FAILED") {
+            resumed.projectedSequences.add(event.sequence);
+        }
+    }
+    logResultRecoveryFailure(delivery, message) {
+        this.host.log(JSON.stringify({
+            event: "feishu_terminal_result_recovery_failed",
+            channel: "feishu",
+            sessionId: delivery.sessionId,
+            runId: delivery.runId,
+            turnId: delivery.turnId,
+            message,
+        }));
+    }
+    async setInboundWebSocketState(state) {
+        await Promise.all([...this.cards.values()].map((card) => card.setInboundWebSocketState(state)));
+        for (const resumed of this.resumedCards.values()) {
+            setInboundWebSocket(resumed.runStatus, state);
+            await this.writeResumedCard(undefined, resumed);
+        }
+    }
+    async setCoreEventStreamState(state) {
+        await Promise.all([...this.cards.values()].map((card) => card.setCoreEventStreamState(state)));
+        for (const resumed of this.resumedCards.values()) {
+            setCoreEventStream(resumed.runStatus, state);
+            await this.writeResumedCard(undefined, resumed);
+        }
+    }
+    recordPermanentCardFailure(runId, messageId, error) {
+        if (classifyFeishuCardWriteError(error) !== "permanent")
+            return false;
+        this.permanentlyInvalidCardIds.add(messageId);
+        if (!this.loggedPermanentCardIds.has(messageId)) {
+            this.loggedPermanentCardIds.add(messageId);
+            this.host.log(JSON.stringify({
+                event: "feishu_card_permanently_invalid",
+                channel: "feishu",
+                sessionId: this.sessionId,
+                runId: runId ?? null,
+                surfaceMessageId: messageId,
+                errorClass: "permanent",
+                message: error instanceof Error ? error.message : String(error),
+            }));
+        }
+        return true;
+    }
+    async writeResumedCard(runId, resumed) {
+        if (this.permanentlyInvalidCardIds.has(resumed.surfaceCardId))
+            return false;
+        // Connection heartbeats must never replace an existing card with an empty projection.
+        if (!resumed.projectionReady && resumed.resultRecovery !== "confirmed")
+            return false;
+        if (resumed.runStatus.state !== "running" && resumed.resultRecovery !== "confirmed")
+            return false;
+        try {
+            await this.host.updateCard(resumed.surfaceCardId, this.resumedCardBody(resumed), resumed.surfaceMessageId);
+            setHttpWrite(resumed.runStatus, "healthy");
+            return true;
+        }
+        catch (error) {
+            if (this.recordPermanentCardFailure(runId, resumed.surfaceCardId, error)) {
+                setHttpWrite(resumed.runStatus, "unavailable");
+                return false;
+            }
+            setHttpWrite(resumed.runStatus, "degraded");
+            throw error;
+        }
+    }
+    resumedCardBody(resumed) {
+        const status = renderFeishuRunStatus(resumed.runStatus);
+        const snapshot = resumed.projector.snapshot();
+        const agentText = resumed.runStatus.state === "running"
+            ? snapshot.liveText
+            : resumed.resultRecovery === "pending"
+                ? "⏳ 结果恢复中"
+                : snapshot.finalText;
+        return runCardJson({
+            answer: resumed.runStatus.state === "running" ? snapshot.result : agentText,
+            progress: (resumed.runStatus.state === "running"
+                ? [snapshot.thinking, snapshot.progress].filter(Boolean).join("\n\n") : ""),
+            status,
+            terminal: resumed.runStatus.state !== "running",
+        });
+    }
+    async openCardForRun(runId, turn) {
+        if (this.cards.has(runId))
+            return;
+        const card = new FeishuRunCard(this.host, turn.chatId, turn.sourceMessageId, runId, turn.showThinking);
+        this.cards.set(runId, card);
+        const owner = `feishu:${this.instanceId}:${runId}`;
+        try {
+            const claimed = await this.ingress.claimDelivery(turn.turnId, owner);
+            if (!claimed) {
+                this.cards.delete(runId);
+                return;
+            }
+            await card.open();
+            const cardId = card.cardMessageId;
+            const cardInstanceId = card.cardInstanceId;
+            if (!cardId || !cardInstanceId) {
+                throw new Error(`card did not produce a message id for run ${runId}`);
+            }
+            const acked = await this.ingress.ackDelivery(turn.turnId, owner, cardId, cardInstanceId);
+            if (!acked) {
+                throw new Error(`ack delivery failed for run ${runId}`);
+            }
+            this.deliveries.set(runId, { turnId: turn.turnId, owner });
+        }
+        catch (err) {
+            this.cards.delete(runId);
+            card.abort();
+            throw err;
+        }
+    }
+    async run() {
+        while (!this.abortController.signal.aborted) {
+            try {
+                const pending = [...this.resumedCards.entries()].filter(([, card]) => !card.projectionReady);
+                if (pending.length && this.ingress.replayEvents) {
+                    const history = await this.ingress.replayEvents(this.sessionId, { afterSequence: this.afterSequence });
+                    for (const [runId, card] of pending) {
+                        this.finishProjectionReplay(runId, card, history);
+                    }
+                }
+                await this.setCoreEventStreamState("connected").catch(() => { });
+                for await (const event of this.ingress.events(this.sessionId, {
+                    afterSequence: this.afterSequence,
+                    signal: this.abortController.signal,
+                })) {
+                    await this.handle(event);
+                    // 状态转换成功后才推进 cursor；失败会抛错并由外层按旧 cursor 重连重放。
+                    this.afterSequence = event.sequence;
+                }
+            }
+            catch (err) {
+                if (this.abortController.signal.aborted)
+                    return;
+                await this.setCoreEventStreamState("reconnecting").catch(() => { });
+                this.host.log(`session watcher 断线，按 sequence ${this.afterSequence} 重连：${err instanceof Error ? err.message : String(err)}`);
+                await new Promise((resolve) => setTimeout(resolve, 250));
+            }
+        }
+    }
+    async handle(event) {
+        if (event.type === "TURN_DISPATCHED" && event.runId && event.target) {
+            const turn = this.pendingTurns.get(event.target);
+            if (turn) {
+                await this.openCardForRun(event.runId, turn);
+                this.pendingTurns.delete(event.target);
+            }
+            return;
+        }
+        if (event.type === "AGENT_EVENT" && event.runId) {
+            const card = this.cards.get(event.runId);
+            const resumed = this.resumedCards.get(event.runId);
+            const agentEvent = event.payload.event;
+            if (agentEvent?.type === "error" && agentEvent.fatal && event.runId) {
+                this.fatalAgentErrorRuns.add(event.runId);
+            }
+            if (resumed && agentEvent) {
+                this.applyRecoveredEvent(event.runId, resumed, event);
+            }
+            if (card && agentEvent && agentEvent.type !== "done") {
+                await card.onAgentEvent(agentEvent);
+            }
+            return;
+        }
+        if (event.type === "STEP_FAILED" && event.runId) {
+            const message = String(event.payload?.error ?? "Step failed");
+            if (!this.fatalAgentErrorRuns.has(event.runId)) {
+                const card = this.cards.get(event.runId);
+                if (card)
+                    await card.onAgentEvent({ type: "error", message });
+            }
+            return;
+        }
+        const terminalState = terminalStateForEvent(event.type);
+        if (terminalState && event.runId) {
+            const card = this.cards.get(event.runId);
+            if (card) {
+                try {
+                    await card.finalize(terminalState);
+                    this.cards.delete(event.runId);
+                }
+                catch (error) {
+                    const messageId = card.cardMessageId;
+                    if (messageId && this.recordPermanentCardFailure(event.runId, messageId, error)) {
+                        card.abort();
+                        this.cards.delete(event.runId);
+                        return;
+                    }
+                    throw error;
+                }
+            }
+            const resumed = this.resumedCards.get(event.runId);
+            if (resumed) {
+                if (!resumed.projectionReady) {
+                    resumed.pendingReplayEvents.push(event);
+                    if (this.ingress.replayEvents)
+                        return;
+                    // Legacy ingress replays its ordered event stream through the terminal event.
+                    this.finishProjectionReplay(event.runId, resumed, []);
+                }
+                resumed.resultRecovery = "confirmed";
+                finishFeishuRunStatus(resumed.runStatus, terminalState);
+                const written = await this.writeResumedCard(event.runId, resumed);
+                if (!written)
+                    return;
+            }
+            await this.completeDeliveryForRun(event.runId);
+        }
+    }
+    async completeDeliveryForRun(runId) {
+        const delivery = this.deliveries.get(runId);
+        if (!delivery)
+            return;
+        const completed = await this.ingress.completeDelivery(delivery.turnId, delivery.owner);
+        if (!completed) {
+            throw new Error(`complete delivery returned false for run ${runId}`);
+        }
+        this.deliveries.delete(runId);
+        this.resumedCards.delete(runId);
+    }
+    abort() {
+        this.abortController.abort();
+        for (const card of this.cards.values())
+            card.abort();
+        this.cards.clear();
+        this.resumedCards.clear();
+        this.pendingTurns.clear();
+    }
+}
+//# sourceMappingURL=session-watcher.js.map

package/node_modules/@codebridge/channel-feishu/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@codebridge/channel-feishu",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/core": "0.1.0",
+    "@codebridge/router": "0.1.0",
+    "@larksuiteoapi/node-sdk": "1.68.0"
+  }
+}

package/node_modules/@codebridge/channel-telegram/dist/coalescing-message-writer.d.ts

@@ -0,0 +1,14 @@
+/** Serializes Telegram edits and collapses queued snapshots to the latest text. */
+export declare class CoalescingMessageWriter {
+    private readonly write;
+    private readonly onError?;
+    private pending;
+    private draining;
+    private closed;
+    constructor(write: (text: string) => Promise<void>, onError?: ((error: unknown) => void) | undefined);
+    enqueue(text: string): void;
+    flush(): Promise<void>;
+    close(): void;
+    private drain;
+}
+//# sourceMappingURL=coalescing-message-writer.d.ts.map