@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/bridge/dist/work-item-api.js

@@ -0,0 +1,414 @@
+import { Hono } from "hono";
+import { randomUUID } from "node:crypto";
+const WORK_ITEM_MODES = [
+    "auto",
+    "investigation",
+    "change",
+    "review",
+    "release",
+    "observe",
+];
+export function createWorkItemApp(store, token, approvals, executor) {
+    const app = new Hono();
+    app.use("/v1/*", async (c, next) => {
+        if (c.req.header("authorization") !== `Bearer ${token}`) {
+            return errorResponse(c, 401, "unauthorized", "未授权");
+        }
+        await next();
+    });
+    app.post("/v1/work-items", async (c) => {
+        const idempotencyKey = c.req.header("idempotency-key");
+        if (idempotencyKey) {
+            const cached = store.getIdempotencyResponse("create-work-item", idempotencyKey);
+            if (cached !== undefined)
+                return c.json(cached, 201);
+        }
+        const body = await readJson(c);
+        const input = parseCreateInput(body);
+        if (!input) {
+            return errorResponse(c, 400, "invalid_work_item", "conversation_id 和 message 必填；title、agent_id、mode 可由 Agent 自动判断");
+        }
+        try {
+            const workItem = store.createWorkItem(input);
+            store.appendEvent({
+                workItemId: workItem.id,
+                type: "MESSAGE_RECEIVED",
+                actor: "user",
+                payload: { message: input.message },
+            });
+            const response = toApiWorkItem(workItem);
+            if (idempotencyKey)
+                store.putIdempotencyResponse("create-work-item", idempotencyKey, response);
+            return c.json(response, 201);
+        }
+        catch (error) {
+            return errorResponse(c, 400, "work_item_create_failed", messageOf(error));
+        }
+    });
+    app.get("/v1/work-items", (c) => {
+        return c.json({ work_items: store.listWorkItems().map(toApiWorkItem) });
+    });
+    app.get("/v1/work-items/:work_item_id", (c) => {
+        const workItem = store.getWorkItem(c.req.param("work_item_id"));
+        if (!workItem) {
+            return errorResponse(c, 404, "work_item_not_found", "WorkItem 不存在");
+        }
+        return c.json(toApiWorkItem(workItem));
+    });
+    app.post("/v1/work-items/:work_item_id/messages", async (c) => {
+        const workItemId = c.req.param("work_item_id");
+        if (!store.getWorkItem(workItemId)) {
+            return errorResponse(c, 404, "work_item_not_found", "WorkItem 不存在");
+        }
+        const body = await readJson(c);
+        if (!body ||
+            typeof body.message !== "string" ||
+            body.message.trim() === "") {
+            return errorResponse(c, 400, "invalid_message", "message 必填");
+        }
+        const idempotencyKey = c.req.header("idempotency-key");
+        if (idempotencyKey) {
+            const cached = store.getIdempotencyResponse(`message:${workItemId}`, idempotencyKey);
+            if (cached !== undefined)
+                return c.json(cached, 202);
+        }
+        const event = store.appendEvent({
+            workItemId,
+            type: "MESSAGE_RECEIVED",
+            actor: body.actor === "channel" ? "channel" : "user",
+            payload: { message: body.message },
+        });
+        const response = {
+            request_id: `req_${randomUUID().replaceAll("-", "")}`,
+            accepted: true,
+            event_id: event.eventId,
+            sequence: event.sequence,
+        };
+        if (idempotencyKey)
+            store.putIdempotencyResponse(`message:${workItemId}`, idempotencyKey, response);
+        return c.json(response, 202);
+    });
+    app.post("/v1/work-items/:work_item_id/runs", async (c) => {
+        const workItemId = c.req.param("work_item_id");
+        const workItem = store.getWorkItem(workItemId);
+        if (!workItem) {
+            return errorResponse(c, 404, "work_item_not_found", "WorkItem 不存在");
+        }
+        const body = await readJson(c);
+        if (!body ||
+            typeof body.mode !== "string" ||
+            !WORK_ITEM_MODES.includes(body.mode) ||
+            body.execution_kind !== "agent") {
+            return errorResponse(c, 400, "invalid_run", "mode 与 execution_kind 必须有效");
+        }
+        if (body.plan_id !== undefined &&
+            body.plan_id !== null &&
+            typeof body.plan_id !== "string") {
+            return errorResponse(c, 400, "invalid_run", "plan_id 无效");
+        }
+        const idempotencyKey = c.req.header("idempotency-key");
+        if (idempotencyKey) {
+            const cached = store.getIdempotencyResponse(`run:${workItemId}`, idempotencyKey);
+            if (cached !== undefined)
+                return c.json(cached, 202);
+        }
+        try {
+            const run = store.createRun({
+                workItemId,
+                mode: body.mode,
+                executionKind: body.execution_kind,
+                planId: body.plan_id ?? null,
+            });
+            if (executor) {
+                void executor.execute(run.id).catch(() => {
+                    // RunExecutor persists the failure event and status. The event stream
+                    // is the durable error channel for clients that created the Run.
+                });
+            }
+            const response = {
+                run_id: run.id,
+                status: run.status,
+                execution_kind: run.executionKind,
+            };
+            if (idempotencyKey)
+                store.putIdempotencyResponse(`run:${workItemId}`, idempotencyKey, response);
+            return c.json(response, 202);
+        }
+        catch (error) {
+            return errorResponse(c, 400, "run_create_failed", messageOf(error));
+        }
+    });
+    app.post("/v1/runs/:run_id/approve", async (c) => {
+        if (!approvals) {
+            return errorResponse(c, 503, "approval_unavailable", "审批服务未配置");
+        }
+        const run = store.getRun(c.req.param("run_id"));
+        if (!run)
+            return errorResponse(c, 404, "run_not_found", "Run 不存在");
+        const body = await readJson(c);
+        if (!body || typeof body.approval_id !== "string") {
+            return errorResponse(c, 400, "invalid_approval", "approval_id 必填");
+        }
+        const approval = approvals.get(body.approval_id);
+        if (!approval || approval.runId !== run.id) {
+            return errorResponse(c, 404, "approval_not_found", "审批记录不存在");
+        }
+        const granted = approvals.grant(approval.id, body.granted_by === "system" ? "system" : "user");
+        if (!granted || granted.status !== "granted") {
+            return errorResponse(c, 409, "approval_not_grantable", "审批已过期或已处理");
+        }
+        store.requeueRun(run.id);
+        if (executor)
+            void executor.execute(run.id).catch(() => { });
+        return c.json({ approval_id: granted.id, status: granted.status, granted_at: granted.grantedAt });
+    });
+    app.get("/v1/runs/:run_id/approvals", (c) => {
+        if (!approvals)
+            return errorResponse(c, 503, "approval_unavailable", "审批服务未配置");
+        const run = store.getRun(c.req.param("run_id"));
+        if (!run)
+            return errorResponse(c, 404, "run_not_found", "Run 不存在");
+        return c.json({ approvals: approvals.listForRun(run.id).map(toApiApproval) });
+    });
+    app.get("/v1/runs/:run_id/artifacts", (c) => {
+        const run = store.getRun(c.req.param("run_id"));
+        if (!run)
+            return errorResponse(c, 404, "run_not_found", "Run 不存在");
+        return c.json({ artifacts: store.listArtifacts(run.id).map((artifact) => toApiArtifact(artifact, false)) });
+    });
+    app.get("/v1/runs/:run_id/verifications", (c) => {
+        const run = store.getRun(c.req.param("run_id"));
+        if (!run)
+            return errorResponse(c, 404, "run_not_found", "Run 不存在");
+        return c.json({ verifications: store.listVerifications(run.id).map(toApiVerification) });
+    });
+    app.get("/v1/artifacts/:artifact_id", (c) => {
+        const artifact = store.getArtifact(c.req.param("artifact_id"));
+        if (!artifact)
+            return errorResponse(c, 404, "artifact_not_found", "Artifact 不存在");
+        return c.json(toApiArtifact(artifact, true));
+    });
+    app.post("/v1/runs/:run_id/reject", async (c) => {
+        if (!approvals) {
+            return errorResponse(c, 503, "approval_unavailable", "审批服务未配置");
+        }
+        const run = store.getRun(c.req.param("run_id"));
+        if (!run)
+            return errorResponse(c, 404, "run_not_found", "Run 不存在");
+        const body = await readJson(c);
+        if (!body || typeof body.approval_id !== "string") {
+            return errorResponse(c, 400, "invalid_approval", "approval_id 必填");
+        }
+        const approval = approvals.get(body.approval_id);
+        if (!approval || approval.runId !== run.id) {
+            return errorResponse(c, 404, "approval_not_found", "审批记录不存在");
+        }
+        const rejected = approvals.revoke(approval.id, body.rejected_by === "system" ? "system" : "user");
+        if (!rejected || rejected.status !== "revoked") {
+            return errorResponse(c, 409, "approval_not_rejectable", "审批已过期或已处理");
+        }
+        store.updateRunStatus(run.id, "cancelled");
+        store.appendEvent({
+            workItemId: run.workItemId,
+            runId: run.id,
+            type: "RUN_CANCELLED",
+            actor: "user",
+            target: run.id,
+            payload: { approval_id: rejected.id, reason: "approval_rejected" },
+        });
+        return c.json({ approval_id: rejected.id, status: rejected.status });
+    });
+    app.get("/v1/work-items/:work_item_id/events", (c) => {
+        const workItemId = c.req.param("work_item_id");
+        if (!store.getWorkItem(workItemId)) {
+            return errorResponse(c, 404, "work_item_not_found", "WorkItem 不存在");
+        }
+        const lastEventId = c.req.header("last-event-id");
+        const afterSequenceValue = c.req.query("after_sequence") ??
+            (lastEventId ? String(store.sequenceForEventId(workItemId, lastEventId)) : "0");
+        const afterSequence = Number(afterSequenceValue);
+        if (!Number.isInteger(afterSequence) || afterSequence < 0) {
+            return errorResponse(c, 400, "invalid_after_sequence", "after_sequence 无效");
+        }
+        const stream = store
+            .listEvents(workItemId, afterSequence)
+            .map(toSseEvent)
+            .join("");
+        return new Response(stream, {
+            status: 200,
+            headers: {
+                "cache-control": "no-cache",
+                connection: "keep-alive",
+                "content-type": "text/event-stream; charset=utf-8",
+            },
+        });
+    });
+    return app;
+}
+function parseCreateInput(body) {
+    if (!body)
+        return null;
+    const requiredStrings = ["conversation_id", "message"];
+    if (requiredStrings.some((key) => !isNonEmptyString(body[key]))) {
+        return null;
+    }
+    if (body.title !== undefined && body.title !== null && !isNonEmptyString(body.title)) {
+        return null;
+    }
+    if (body.agent_id !== undefined && body.agent_id !== null && !isNonEmptyString(body.agent_id)) {
+        return null;
+    }
+    if (body.mode !== undefined && body.mode !== null && (typeof body.mode !== "string" ||
+        !WORK_ITEM_MODES.includes(body.mode))) {
+        return null;
+    }
+    if (body.workflow_id !== undefined &&
+        body.workflow_id !== null &&
+        typeof body.workflow_id !== "string") {
+        return null;
+    }
+    if (body.workspace_scope !== undefined && !isStringArray(body.workspace_scope)) {
+        return null;
+    }
+    if (body.identifiers !== undefined && !isRecord(body.identifiers)) {
+        return null;
+    }
+    if (body.risk_level !== undefined &&
+        !["read_only", "workspace_write", "git_write", "production_write"].includes(String(body.risk_level))) {
+        return null;
+    }
+    return {
+        title: isNonEmptyString(body.title)
+            ? body.title
+            : deriveTitle(body.message),
+        mode: body.mode ?? "auto",
+        conversationId: body.conversation_id,
+        agentId: body.agent_id ?? null,
+        workflowId: body.workflow_id ?? null,
+        workflowRevision: null,
+        workspaceScope: body.workspace_scope ?? [],
+        identifiers: body.identifiers ?? {},
+        riskLevel: body.risk_level ?? "read_only",
+        message: body.message,
+    };
+}
+function deriveTitle(message) {
+    const compact = message.replace(/\s+/g, " ").trim();
+    return compact.length > 48 ? `${compact.slice(0, 47)}…` : compact;
+}
+async function readJson(c) {
+    const body = await c.req.json().catch(() => null);
+    return isRecord(body) ? body : null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function toApiWorkItem(workItem) {
+    return {
+        schema_version: workItem.schemaVersion,
+        id: workItem.id,
+        title: workItem.title,
+        status: workItem.status,
+        mode: workItem.mode,
+        conversation_id: workItem.conversationId,
+        agent_id: workItem.agentId,
+        workflow_id: workItem.workflowId,
+        workflow_revision: workItem.workflowRevision,
+        workspace_scope: workItem.workspaceScope,
+        identifiers: workItem.identifiers,
+        context_revision: workItem.contextRevision,
+        risk_level: workItem.riskLevel,
+        created_at: workItem.createdAt,
+        updated_at: workItem.updatedAt,
+    };
+}
+function toApiApproval(approval) {
+    return {
+        id: approval.id,
+        work_item_id: approval.workItemId,
+        run_id: approval.runId,
+        step_id: approval.stepId,
+        capability_id: approval.capabilityId,
+        session_id: approval.sessionId,
+        environment: approval.environment,
+        target_resource: approval.targetResource,
+        input_hash: approval.inputHash,
+        status: approval.status,
+        requested_by: approval.requestedBy,
+        granted_by: approval.grantedBy,
+        created_at: approval.createdAt,
+        expires_at: approval.expiresAt,
+        granted_at: approval.grantedAt,
+        consumed_at: approval.consumedAt,
+    };
+}
+function toApiArtifact(artifact, includeContent) {
+    return {
+        id: artifact.id,
+        work_item_id: artifact.workItemId,
+        run_id: artifact.runId,
+        step_id: artifact.stepId,
+        kind: artifact.kind,
+        name: artifact.name,
+        mime_type: artifact.mimeType,
+        content: includeContent ? artifact.content : undefined,
+        content_hash: artifact.contentHash,
+        metadata: artifact.metadata,
+        created_at: artifact.createdAt,
+    };
+}
+function toApiVerification(verification) {
+    return {
+        id: verification.id,
+        work_item_id: verification.workItemId,
+        run_id: verification.runId,
+        step_id: verification.stepId,
+        validator: verification.validator,
+        status: verification.status,
+        summary: verification.summary,
+        artifact_ids: verification.artifactIds,
+        created_at: verification.createdAt,
+    };
+}
+function toSseEvent(event) {
+    return [
+        `id: ${event.eventId}`,
+        `event: ${event.type}`,
+        `data: ${JSON.stringify({
+            schema_version: event.schemaVersion,
+            event_id: event.eventId,
+            sequence: event.sequence,
+            work_item_id: event.workItemId,
+            run_id: event.runId,
+            type: event.type,
+            occurred_at: event.occurredAt,
+            actor: event.actor,
+            target: event.target,
+            input_hash: event.inputHash,
+            result_ref: event.resultRef,
+            payload: event.payload,
+        })}`,
+        "",
+        "",
+    ].join("\n");
+}
+function errorResponse(c, status, code, message, retryable = false) {
+    return c.json({
+        error: {
+            code,
+            message,
+            retryable,
+            request_id: `req_${randomUUID().replaceAll("-", "")}`,
+        },
+    }, status);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=work-item-api.js.map

package/node_modules/@codebridge/bridge/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@codebridge/bridge",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "codebridge": "./dist/cli.js"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@codebridge/channel-feishu": "0.1.0",
+    "@codebridge/channel-telegram": "0.1.0",
+    "@codebridge/core": "0.1.0",
+    "@codebridge/router": "0.1.0",
+    "@codebridge/policy": "0.1.0",
+    "@codebridge/mcp-runtime": "0.1.0",
+    "@codebridge/project-catalog": "0.1.0",
+    "@codebridge/agent-registry": "0.1.0",
+    "@codebridge/session-catalog": "0.1.0",
+    "@codebridge/run-executor": "0.1.0",
+    "@codebridge/runner-client": "0.1.0",
+    "@codebridge/session-coordinator": "0.1.0",
+    "@codebridge/work-items": "0.1.0",
+    "@hono/node-server": "1.19.14",
+    "commander": "12.1.0",
+    "hono": "4.12.27",
+    "yaml": "2.9.0"
+  }
+}

package/node_modules/@codebridge/channel-feishu/dist/alert-reactions.d.ts

@@ -0,0 +1,6 @@
+import type { Client } from "@larksuiteoapi/node-sdk";
+/** Replace only this application's managed state reactions on the original alert. */
+export declare function setAlertReaction(client: Client, appId: string, messageId: string, emojiType: string, managedEmojiTypes: string[]): Promise<string>;
+/** Read any human's DONE, excluding the bot's own projected state. */
+export declare function findHumanDoneReaction(client: Client, messageId: string, after?: number): Promise<import("./alert-types.js").FeishuAlertReaction | undefined>;
+//# sourceMappingURL=alert-reactions.d.ts.map

package/node_modules/@codebridge/channel-feishu/dist/alert-reactions.js

@@ -0,0 +1,58 @@
+/** Replace only this application's managed state reactions on the original alert. */
+export async function setAlertReaction(client, appId, messageId, emojiType, managedEmojiTypes) {
+    if (!managedEmojiTypes.includes(emojiType))
+        throw new Error("Unmanaged alert reaction");
+    const api = client.im.v1.messageReaction;
+    const owned = [];
+    let pageToken;
+    do {
+        const response = await api.list({ path: { message_id: messageId }, params: { page_size: 50, page_token: pageToken } });
+        if (response.code !== 0 || !response.data)
+            throw new Error(`Reaction list failed (${response.code}): ${response.msg}`);
+        owned.push(...response.data.items.filter((item) => item.operator?.operator_type === "app"
+            && item.operator.operator_id === appId && managedEmojiTypes.includes(item.reaction_type?.emoji_type ?? "")));
+        pageToken = response.data.has_more ? response.data.page_token : undefined;
+        if (response.data.has_more && !pageToken)
+            throw new Error("Incomplete reaction pagination");
+    } while (pageToken);
+    let reactionId = owned.find((item) => item.reaction_type?.emoji_type === emojiType)?.reaction_id;
+    if (!reactionId) {
+        const created = await api.create({ path: { message_id: messageId }, data: { reaction_type: { emoji_type: emojiType } } });
+        if (created.code !== 0 || !created.data?.reaction_id)
+            throw new Error(`Reaction create failed (${created.code}): ${created.msg}`);
+        reactionId = created.data.reaction_id;
+    }
+    // Add the new state before removing the old one; retries can read back the newly created state.
+    for (const item of owned) {
+        if (!item.reaction_id || item.reaction_id === reactionId)
+            continue;
+        const removed = await api.delete({ path: { message_id: messageId, reaction_id: item.reaction_id } });
+        if (removed.code !== 0)
+            throw new Error(`Reaction delete failed (${removed.code}): ${removed.msg}`);
+    }
+    return reactionId;
+}
+/** Read any human's DONE, excluding the bot's own projected state. */
+export async function findHumanDoneReaction(client, messageId, after) {
+    let pageToken;
+    do {
+        const result = await client.im.v1.messageReaction.list({ path: { message_id: messageId },
+            params: { reaction_type: "DONE", user_id_type: "open_id", page_size: 50, page_token: pageToken } });
+        if (result.code !== 0 || !result.data)
+            throw new Error(`Reaction read failed (${result.code}): ${result.msg}`);
+        for (const item of result.data.items) {
+            if (item.operator?.operator_type !== "user" || !item.operator.operator_id || item.reaction_type?.emoji_type !== "DONE")
+                continue;
+            const rawTime = Number(item.action_time);
+            const actionTime = Number.isFinite(rawTime) && rawTime > 0 ? rawTime : undefined;
+            if (after !== undefined && (actionTime === undefined || actionTime <= after))
+                continue;
+            return { messageId, operatorOpenId: item.operator.operator_id, operatorType: "user", emojiType: "DONE", action: "added", actionTime };
+        }
+        pageToken = result.data.has_more ? result.data.page_token : undefined;
+        if (result.data.has_more && !pageToken)
+            throw new Error("Incomplete reaction pagination");
+    } while (pageToken);
+    return undefined;
+}
+//# sourceMappingURL=alert-reactions.js.map

package/node_modules/@codebridge/channel-feishu/dist/alert-types.d.ts

@@ -0,0 +1,35 @@
+/** Channel transport values; alert policy and persistence live in the Bridge app. */
+export interface FeishuAlertMessage {
+    messageId: string;
+    chatId: string;
+    createdAt: number;
+    senderId: string;
+    senderType: string;
+    content: string;
+    rootId?: string;
+}
+export interface FeishuAlertPage {
+    messages: FeishuAlertMessage[];
+    hasMore: boolean;
+    pageToken?: string;
+}
+export interface FeishuAlertReply {
+    allowed: boolean;
+    handled?: boolean;
+    topicId: string;
+    instructions: string;
+    /** Sent back into the thread when the message is refused, so nobody is ignored silently. */
+    notice?: string;
+}
+export declare const FEISHU_ALERT_STATUSES: readonly ["investigating", "waiting", "resolved", "no_action", "blocked", "dismissed"];
+export type FeishuAlertStatus = typeof FEISHU_ALERT_STATUSES[number];
+export interface FeishuAlertReaction {
+    messageId: string;
+    operatorOpenId: string;
+    /** Set when the source can tell humans from apps; anything but a user is ignored. */
+    operatorType?: string;
+    emojiType: string;
+    action: "added" | "removed";
+    actionTime?: number;
+}
+//# sourceMappingURL=alert-types.d.ts.map

package/node_modules/@codebridge/channel-feishu/dist/alert-types.js

@@ -0,0 +1,2 @@
+export const FEISHU_ALERT_STATUSES = ["investigating", "waiting", "resolved", "no_action", "blocked", "dismissed"];
+//# sourceMappingURL=alert-types.js.map

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

@@ -0,0 +1,130 @@
+import type { FeishuAlertMessage, FeishuAlertPage, FeishuAlertReply, FeishuAlertReaction } from "./alert-types.js";
+import { type AppConfig, type ChannelSessionIngress, type RunAttachment } from "@codebridge/core";
+import { RunOrchestrator } from "@codebridge/router";
+export interface FeishuMessage {
+    messageId: string;
+    chatId: string;
+    chatType: "p2p" | "group";
+    senderId: string;
+    senderName?: string;
+    content: string;
+    threadId?: string;
+    /** 回复串的串首消息 id（普通群回复时有值） */
+    rootId?: string;
+    /** 被直接回复（引用）的消息 id */
+    replyToMessageId?: string;
+    mentionedBot?: boolean;
+    mentions?: FeishuMention[];
+    attachments?: RunAttachment[];
+    rawContentType?: string;
+    raw?: unknown;
+}
+export interface FeishuMention {
+    openId?: string;
+    userId?: string;
+    name?: string;
+    isBot?: boolean;
+}
+export interface FeishuBridgeOptions {
+    config: AppConfig;
+    dataDir: string;
+    onLog?: (msg: string) => void;
+    sessionIngress?: ChannelSessionIngress;
+    onDeploymentMessage?: (message: FeishuMessage) => Promise<string | undefined>;
+    isMaintenance?: () => boolean;
+    prepareAlertReply?: (message: FeishuMessage, topicId: string | undefined) => FeishuAlertReply | undefined | Promise<FeishuAlertReply | undefined>;
+    isAlertMessage?: (chatId: string, messageId: string) => boolean;
+    isAlertChat?: (chatId: string) => boolean;
+    /** True when one of the candidate ids is a configured alert sender for the chat. */
+    isAlertSender?: (chatId: string, candidateIds: string[]) => boolean;
+    onAlertReaction?: (reaction: FeishuAlertReaction) => Promise<void>;
+}
+/** 把长文本按行切成 ≤ maxLen 的块，用于超长结果分条普通消息发送（避免又撞长度上限） */
+export declare function chunkMarkdown(text: string, maxLen: number): string[];
+export declare class FeishuBridge {
+    private readonly options;
+    private channel?;
+    private orchestrator;
+    private config;
+    /** chat|topic → 最近一条入站消息 id（出站消息回贴话题用） */
+    private readonly lastInboundMessageId;
+    /** 普通群回复串 → 会话 topic 映射 */
+    private readonly chainTopics;
+    /** bot 已参与过的话题（内存；重启后由 Catalog 槽位绑定续上） */
+    private readonly botParticipatedTopics;
+    private readonly mentionRegistry;
+    private readonly pendingStreams;
+    /** 所有活动流的 AbortController（非 chat-scoped），disconnect 时统一 abort */
+    private readonly activeAborts;
+    /** 每 Session 一个持久事件订阅，单订阅路由 Turn/Run/Delivery */
+    private readonly sessionWatchers;
+    private readonly instanceId;
+    private readonly deliveryReconciler;
+    private inboundWebSocketState;
+    private disconnecting;
+    private sessionIngress?;
+    private cardKitWriter?;
+    private readonly cardUpdateSequences;
+    private readonly deliveryRetries;
+    /** turnIds abandoned after FEISHU_DELIVERY_RECONCILE_MAX_ATTEMPTS; reconcileDeliveries skips these until the delivery itself disappears. */
+    private readonly abandonedDeliveries;
+    constructor(options: FeishuBridgeOptions);
+    get isConnected(): boolean;
+    get orchestratorRef(): RunOrchestrator;
+    setSessionIngress(ingress: ChannelSessionIngress): void;
+    updateConfig(config: AppConfig): void;
+    private applyPolicyToChannel;
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private recoverInterruptedStreams;
+    private chatKey;
+    private dispatchInboundMessage;
+    /**
+     * 消息所属会话 topic：话题群直接用 thread_id；普通群把「回复串」映射为
+     * topic——群根发起的对话延续群级会话，回复陌生消息（如告警推送）的串
+     * 自动成为独立话题、开启全新 session。
+     */
+    private resolveTopicId;
+    private handleMessage;
+    /** 组装话题/引用上下文并启动 agent 流式回复 */
+    private dispatchToAgent;
+    private cardHost;
+    /**
+     * Start a fresh provider session (same effect as /new) when the bound one is idle or
+     * its context is too full. Alert incidents are exempt: their alert data lives only in
+     * the first prompt of the topic session.
+     */
+    private rotateStaleSession;
+    private buildFullSlot;
+    private ensureSessionWatcher;
+    private reconcileDeliveries;
+    private submitAndStream;
+    private streamAgentReply;
+    private sendMarkdown;
+    /**
+     * 话题群出站消息定位：带 topicId 时回贴到该话题最近一条入站消息，
+     * 否则（或 Bridge 重启后话题内还没有新消息）落到群根/单聊。
+     */
+    private outboundSendOptions;
+    /** Transport adapter for the Bridge-owned alert monitor; always uses bot credentials. */
+    readAlertMessages(chatId: string, startTime: number, endTime: number, pageToken?: string): Promise<FeishuAlertPage>;
+    setAlertMessageReaction(messageId: string, emojiType: string, managed: string[]): Promise<string>;
+    notifyAlertOwner(chatId: string, rootId: string, approverOpenIds: string[], text: string): Promise<void>;
+    postAlertThreadNotice(chatId: string, rootId: string, text: string): Promise<void>;
+    alertMemberName(chatId: string, openId: string): Promise<string | undefined>;
+    resolveAlertThreadRoot(messageId: string): Promise<{
+        chatId: string;
+        rootId: string;
+    } | undefined>;
+    readAlertDone(messageId: string, after?: number): Promise<FeishuAlertReaction | undefined>;
+    cancelAlertInvestigation(chatId: string, rootId: string): Promise<void>;
+    isAlertActive(chatId: string, rootId: string): Promise<boolean>;
+    investigateAlert(alert: FeishuAlertMessage, approverOpenIds: string[], instructions: string): Promise<void>;
+    /** 出站 API：把本机文件作为文件消息发进聊天（供 Agent 内 fcb 调用） */
+    sendOutboundFile(chatId: string, rawPath: string, topicId?: string): Promise<string>;
+    /** 出站 API：把 markdown 消息发进聊天（供 Agent 内 fcb 调用） */
+    sendOutboundMarkdown(chatId: string, markdown: string, topicId?: string): Promise<void>;
+    sendOutboundMention(chatId: string, ref: string, text: string, topicId?: string): Promise<void>;
+}
+export declare function runDoctor(config: AppConfig, dataDir: string): Promise<Record<string, unknown>>;
+//# sourceMappingURL=bridge.d.ts.map