@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/channel-feishu/dist/run-status.d.ts

@@ -0,0 +1,39 @@
+import type { AgentEvent, ChannelDeliveryRunSnapshot } from "@codebridge/core";
+export declare const FEISHU_LIVE_STATUS_QUIET_MS: number;
+export type FeishuRunState = "running" | "succeeded" | "failed" | "cancelled" | "interrupted";
+export type FeishuConnectionState = "connected" | "reconnecting" | "unavailable";
+export type FeishuHttpWriteState = "healthy" | "degraded" | "unavailable";
+export interface FeishuTransportSnapshot {
+    coreEventStream: FeishuConnectionState;
+    feishuInboundWebSocket: FeishuConnectionState;
+    feishuHttpWrite: FeishuHttpWriteState;
+}
+export interface FeishuRunStatus {
+    startedAt: number;
+    lastActivityAt: number;
+    lastVerifiedAt?: number;
+    phase: string;
+    state: FeishuRunState;
+    endedAt?: number;
+    transport: FeishuTransportSnapshot;
+    verificationError?: string;
+    /** 请求的 model 未被适配器采纳时的请求值/实际生效值对照（见 model_resolved 事件） */
+    modelMismatch?: {
+        requested: string;
+        effective?: string;
+        effectiveName?: string;
+    };
+}
+export declare function createFeishuRunStatus(now?: number): FeishuRunStatus;
+export declare function recordRunVerification(status: FeishuRunStatus, now?: number): void;
+export declare function recordRunVerificationFailure(status: FeishuRunStatus, message: string): void;
+export declare function setCoreEventStream(status: FeishuRunStatus, state: FeishuConnectionState): void;
+export declare function setFeishuInboundWebSocket(status: FeishuRunStatus, state: FeishuConnectionState): void;
+export declare const setInboundWebSocket: typeof setFeishuInboundWebSocket;
+export declare function setFeishuHttpWrite(status: FeishuRunStatus, state: FeishuHttpWriteState): void;
+export declare const setHttpWrite: typeof setFeishuHttpWrite;
+export declare function applyRunSnapshot(status: FeishuRunStatus, snapshot: ChannelDeliveryRunSnapshot, now?: number): boolean;
+export declare function recordFeishuRunActivity(status: FeishuRunStatus, event: AgentEvent, now?: number): boolean;
+export declare function finishFeishuRunStatus(status: FeishuRunStatus, state: Exclude<FeishuRunState, "running">, now?: number): boolean;
+export declare function renderFeishuRunStatus(status: FeishuRunStatus, now?: number): string;
+//# sourceMappingURL=run-status.d.ts.map

package/node_modules/@codebridge/channel-feishu/dist/run-status.js

@@ -0,0 +1,166 @@
+import { formatElapsed } from "@codebridge/router";
+export const FEISHU_LIVE_STATUS_QUIET_MS = 5 * 60_000;
+export function createFeishuRunStatus(now = Date.now()) {
+    return {
+        startedAt: now,
+        lastActivityAt: now,
+        phase: "任务启动",
+        state: "running",
+        transport: {
+            coreEventStream: "connected",
+            feishuInboundWebSocket: "connected",
+            feishuHttpWrite: "healthy",
+        },
+    };
+}
+export function recordRunVerification(status, now = Date.now()) {
+    status.lastVerifiedAt = now;
+    status.verificationError = undefined;
+}
+export function recordRunVerificationFailure(status, message) {
+    status.verificationError = message;
+}
+export function setCoreEventStream(status, state) {
+    status.transport.coreEventStream = state;
+}
+export function setFeishuInboundWebSocket(status, state) {
+    status.transport.feishuInboundWebSocket = state;
+}
+export const setInboundWebSocket = setFeishuInboundWebSocket;
+export function setFeishuHttpWrite(status, state) {
+    status.transport.feishuHttpWrite = state;
+}
+export const setHttpWrite = setFeishuHttpWrite;
+function parsedTimestamp(value) {
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+export function applyRunSnapshot(status, snapshot, now = Date.now()) {
+    recordRunVerification(status, now);
+    const startedAt = parsedTimestamp(snapshot.createdAt);
+    const updatedAt = parsedTimestamp(snapshot.updatedAt);
+    if (startedAt !== undefined)
+        status.startedAt = startedAt;
+    const terminalState = snapshot.status === "succeeded" ||
+        snapshot.status === "failed" ||
+        snapshot.status === "cancelled" ||
+        snapshot.status === "interrupted"
+        ? snapshot.status
+        : undefined;
+    if (!terminalState) {
+        if (status.state !== "running")
+            return false;
+        if (snapshot.status === "queued")
+            status.phase = "等待执行";
+        if (snapshot.status === "waiting")
+            status.phase = "等待步骤审批";
+        return true;
+    }
+    if (status.state !== "running")
+        return status.state === terminalState;
+    status.state = terminalState;
+    status.endedAt = updatedAt ?? now;
+    if (snapshot.terminalReason)
+        status.phase = snapshot.terminalReason;
+    return true;
+}
+export function recordFeishuRunActivity(status, event, now = Date.now()) {
+    if (status.state !== "running")
+        return false;
+    if (event.type === "model_resolved") {
+        status.modelMismatch = {
+            requested: event.requested,
+            effective: event.effective,
+            effectiveName: event.effectiveName,
+        };
+        status.lastActivityAt = now;
+        return true;
+    }
+    let phase;
+    switch (event.type) {
+        case "thought_delta":
+            phase = "分析任务";
+            break;
+        case "text_delta":
+            phase = event.phase === "commentary" ? "任务检查点" : "生成最终回复";
+            break;
+        case "tool_start":
+            phase = `工具执行：${event.name}`;
+            break;
+        case "tool_update":
+            phase = event.name ? `工具执行：${event.name}` : status.phase;
+            break;
+        case "tool_end":
+            phase = event.name ? `工具完成：${event.name}` : "工具完成";
+            break;
+        case "plan":
+        case "plan_update":
+        case "plan_removed":
+            phase = "更新计划";
+            break;
+        case "permission_request":
+            phase = "等待权限确认";
+            break;
+        default:
+            return false;
+    }
+    status.lastActivityAt = now;
+    status.phase = phase;
+    return true;
+}
+export function finishFeishuRunStatus(status, state, now = Date.now()) {
+    if (status.state !== "running")
+        return false;
+    status.state = state;
+    status.endedAt = now;
+    return true;
+}
+export function renderFeishuRunStatus(status, now = Date.now()) {
+    const terminal = status.state !== "running";
+    const observedAt = terminal ? status.endedAt ?? now : now;
+    const elapsed = Math.max(0, observedAt - status.startedAt);
+    const sinceActivity = Math.max(0, observedAt - status.lastActivityAt);
+    let title;
+    let phase = status.phase.replace(/[\r\n]+/g, " ").trim() || "—";
+    if (status.state !== "running") {
+        const titles = {
+            succeeded: "✅ **已完成**",
+            failed: "❌ **已失败**",
+            cancelled: "⏹ **已停止**",
+            interrupted: "⚠️ **已中断**",
+        };
+        title = titles[status.state];
+    }
+    else {
+        const quiet = sinceActivity >= FEISHU_LIVE_STATUS_QUIET_MS;
+        const coreEventStream = status.transport.coreEventStream;
+        title =
+            coreEventStream === "reconnecting"
+                ? "⚠️ **事件流重连中 · 后台任务仍在运行**"
+                : coreEventStream === "unavailable" || status.verificationError
+                    ? "⚠️ **状态核验暂不可用 · 后台任务状态待确认**"
+                    : quiet
+                        ? "🟠 **任务运行中 · 暂无新事件**"
+                        : "🟢 **执行中**";
+        if (quiet)
+            phase = `${phase}（暂无新事件）`;
+    }
+    const lines = [
+        `任务状态：${title}`,
+        `运行时长：${formatElapsed(elapsed)}`,
+        `最近任务事件：${formatElapsed(sinceActivity)}前`,
+    ];
+    // 只在实际生效模型与用户请求不一致时提示，避免正常运行多一行噪音
+    if (status.modelMismatch) {
+        const { requested, effective, effectiveName } = status.modelMismatch;
+        // 适配器的 value 机器味重（`opus[1m]`、`grok-4.6[effort=high,fast=true]`），
+        // 有可读 name 就以 name 为主、原值放括号里，两边都能对上。
+        const shown = effectiveName ? `${effectiveName}（${effective}）` : effective;
+        lines.push(shown
+            ? `实际使用模型：${shown}，请求的是 ${requested}`
+            : `请求的模型 ${requested} 未生效，本次运行使用了该 Agent 的默认模型。`);
+    }
+    lines.push(`当前阶段：${phase}`);
+    return lines.join("\n");
+}
+//# sourceMappingURL=run-status.js.map

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

@@ -0,0 +1,98 @@
+import type { AgentEvent, ChannelDeliveryRow, ChannelDeliveryRunSnapshot, ChannelSessionIngress } from "@codebridge/core";
+import { type MarkdownCardStream } from "./durable-markdown-card.js";
+import { type FeishuConnectionState, type FeishuRunState } from "./run-status.js";
+export declare const FEISHU_LIVE_STATUS_TICK_MS = 15000;
+export { FEISHU_LIVE_STATUS_QUIET_MS } from "./run-status.js";
+export declare function classifyFeishuCardWriteError(error: unknown): "transient" | "permanent";
+export interface PendingFeishuStream {
+    chatId: string;
+    sourceMessageId: string;
+    startedAt: string;
+}
+export interface FeishuCardHost {
+    channel?: MarkdownCardStream;
+    sendMarkdown(chatId: string, markdown: string, replyTo?: string): Promise<void>;
+    resolveCardId?(messageId: string): Promise<string>;
+    /** Update the CardKit instance itself, never the referencing IM message. */
+    updateCard(cardId: string, card: object, replyTo?: string): Promise<void>;
+    registerPendingStream(messageId: string, entry: PendingFeishuStream): void;
+    clearPendingStream(messageId: string): void;
+    log(message: string): void;
+    isDisconnecting(): boolean;
+}
+/** 一个 Run 的飞书流式卡片。开卡后由 watcher 喂 AgentEvent，终态时 finalize。 */
+export declare class FeishuRunCard {
+    private readonly host;
+    private readonly chatId;
+    private readonly sourceMessageId;
+    readonly runId: string;
+    private readonly projector;
+    private readonly runStatus;
+    private readonly abortController;
+    private readonly cardDone;
+    private cardDoneResolve;
+    private readyResolve;
+    private readonly ready;
+    private writer?;
+    private lastWriteError?;
+    private streamMessageId?;
+    private streamCardId?;
+    private queueRender;
+    private done;
+    constructor(host: FeishuCardHost, chatId: string, sourceMessageId: string, runId: string, showThinking: boolean);
+    get signal(): AbortSignal;
+    get cardMessageId(): string | undefined;
+    get cardInstanceId(): string | undefined;
+    open(): Promise<void>;
+    onAgentEvent(event: AgentEvent): Promise<void>;
+    reconcileRun(snapshot: ChannelDeliveryRunSnapshot, inboundState: FeishuConnectionState): Promise<void>;
+    setCoreEventStreamState(state: FeishuConnectionState): Promise<void>;
+    setInboundWebSocketState(state: FeishuConnectionState): Promise<void>;
+    finalize(terminalState: Exclude<FeishuRunState, "running">): Promise<void>;
+    abort(): void;
+}
+export interface PendingTurn {
+    turnId: string;
+    chatId: string;
+    sourceMessageId: string;
+    showThinking: boolean;
+}
+/** 每 Session 一个持久 events 订阅，单订阅统一路由 Turn / Run / Delivery。 */
+export declare class FeishuSessionWatcher {
+    private readonly host;
+    private readonly ingress;
+    private readonly sessionId;
+    private readonly instanceId;
+    private readonly abortController;
+    private afterSequence;
+    private started;
+    private readonly cards;
+    private readonly pendingTurns;
+    private readonly deliveries;
+    private readonly resumedCards;
+    private readonly fatalAgentErrorRuns;
+    private readonly permanentlyInvalidCardIds;
+    private readonly loggedPermanentCardIds;
+    constructor(host: FeishuCardHost, ingress: ChannelSessionIngress, sessionId: string, instanceId: string);
+    /** 注入初始 cursor 后再启动，避免启动后登记 pending Turn/开卡前消费事件。 */
+    start(afterSequence: number): void;
+    registerPendingTurn(turnId: string, turn: PendingTurn): void;
+    /** 恢复 delivering 状态：按 surfaceMessageId 重放事件投影最终回答，终态更新原卡片。 */
+    resumeCardForRun(runId: string, surfaceMessageId: string, turnId: string, owner: string, showThinking: boolean, surfaceCardId: string): void;
+    reconcileDelivery(delivery: ChannelDeliveryRow, turn: PendingTurn, inboundState: FeishuConnectionState): Promise<void>;
+    private restorePersistedResult;
+    private finishProjectionReplay;
+    private applyRecoveredEvent;
+    private logResultRecoveryFailure;
+    setInboundWebSocketState(state: FeishuConnectionState): Promise<void>;
+    private setCoreEventStreamState;
+    private recordPermanentCardFailure;
+    private writeResumedCard;
+    private resumedCardBody;
+    openCardForRun(runId: string, turn: PendingTurn): Promise<void>;
+    private run;
+    private handle;
+    private completeDeliveryForRun;
+    abort(): void;
+}
+//# sourceMappingURL=session-watcher.d.ts.map