@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/bridge/dist/deployment.js

@@ -0,0 +1,174 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const commands = {
+    "准备发布": { action: "prepare" },
+    "把刚才改的上线": { action: "publish" },
+    "上线": { action: "publish" },
+    "发布这次修改": { action: "publish" },
+    "上线了吗": { action: "status" },
+    "发布状态": { action: "status" },
+    "取消这次发布": { action: "cancel" },
+    "退回上一个版本": { action: "rollback" },
+    "回滚到上一版": { action: "rollback" },
+    "测好后上线": { action: "prepare", publishAfterPrepare: true },
+};
+export function parseDeploymentCommand(text) {
+    const normalized = text.trim().replace(/[。！!？?]+$/, "").trim()
+        .replace(/^(?:请|帮我)/, "").replace(/吧$/, "").trim();
+    const value = Object.hasOwn(commands, normalized) ? commands[normalized] : undefined;
+    return value ? { ...value } : undefined;
+}
+export function hasPublishIntent(text) {
+    if (/[“”"「」『』`]|不要|不用|别|不必|不发布|不上线|先不|暂不/.test(text))
+        return false;
+    return /(?:测好后上线|测试通过后上线|测好后发布|改好后上线|并上线|然后上线|完成后上线)[。！!\s]*$/.test(text.trim());
+}
+export class DeploymentService {
+    options;
+    nativeMessages = new Map();
+    constructor(options = {}) {
+        this.options = options;
+    }
+    get configPath() {
+        return this.options.configPath ?? path.join(os.homedir(), ".codebridge", "deployer", "config.json");
+    }
+    readConfig() {
+        try {
+            return JSON.parse(fs.readFileSync(this.configPath, "utf8"));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    isOwner(actorId) {
+        return Boolean(actorId && this.readConfig()?.ownerOpenId === actorId);
+    }
+    isMaintenance() {
+        const config = this.readConfig();
+        return Boolean(config && fs.existsSync(path.join(config.rootDir ?? path.dirname(this.configPath), "maintenance.json")));
+    }
+    readiness() {
+        return {
+            ok: true,
+            releaseId: process.env.CODEBRIDGE_RELEASE_ID ?? "bootstrap",
+            commit: process.env.CODEBRIDGE_RELEASE_COMMIT ?? "bootstrap",
+            feishuConnected: this.options.feishuConnected?.() ?? false,
+            activeRuns: this.options.activeRuns?.() ?? 0,
+            maintenance: this.isMaintenance(),
+        };
+    }
+    async command(command, context) {
+        const config = this.readConfig();
+        if (!config?.token)
+            return "安全发布还没有配置，请先在主机完成安装。普通对话可以继续。";
+        if (!config.ownerOpenId || config.ownerOpenId !== context.actorId)
+            return "只有已绑定的发布负责人可以操作安全发布。";
+        try {
+            const response = await (this.options.fetch ?? fetch)("http://127.0.0.1:19791/command", {
+                method: "POST",
+                headers: { authorization: `Bearer ${config.token}`, "content-type": "application/json" },
+                body: JSON.stringify({ ...command, ...context }),
+                signal: AbortSignal.timeout(10_000),
+            });
+            const result = await response.json();
+            return typeof result.message === "string" ? result.message : "发布控制器返回异常，请稍后查询发布状态。";
+        }
+        catch {
+            return "暂时联系不上本机发布控制器，请稍后再试。普通对话可以继续。";
+        }
+    }
+    nativeContext(messageId) {
+        return this.nativeMessages.get(messageId);
+    }
+    guidance(actorId, text) {
+        if (!this.isOwner(actorId))
+            return "";
+        const sourceRepo = this.readConfig()?.sourceRepo;
+        // Scope first: this note must never read as a verdict on other projects' push/deploy authorization.
+        return "【CodeBridge 自身修改，仅在本任务修改 CodeBridge 时适用；不涉及其他项目，其他项目的推送、合并、上线授权只以用户原话为准】"
+            + (sourceRepo ? `CodeBridge 修改目录：${sourceRepo}。必须在此目录修改并提交候选。` : "")
+            + (hasPublishIntent(text)
+                ? "本条消息含发布指令（如“测好后上线”）：仅当本任务修改的是 CodeBridge 时，测试通过后可用 codebridge_deploy（action=prepare,publishAfterPrepare=true）。"
+                : "本条消息未包含 CodeBridge 发布指令（如“测好后上线”），CodeBridge 只用 codebridge_deploy（action=prepare）准备候选并报告结果。")
+            + "验证并提交后优先用 MCP 工具；沙箱内不要通过 shell/fcb 访问网络；禁止直接重启或覆盖运行目录。MCP 不可用时才考虑 fcb，禁止为发布关闭沙箱或放宽网络权限。";
+    }
+    guidanceForRun(runId, store) {
+        const run = store.getRun(runId);
+        const turn = run?.turnId ? store.getTurn(run.turnId) : undefined;
+        const actor = turn?.message.actorRef;
+        if (actor?.channel !== "feishu")
+            return "";
+        const delivery = store.listDeliveries("feishu").find((item) => item.turnId === turn?.turnId && item.runId === runId);
+        const native = delivery ? this.nativeContext(delivery.replyToMessageId) : undefined;
+        if (!native || native.senderId !== actor.id || native.chatId !== delivery?.conversationId.split("|")[0])
+            return "";
+        return this.guidance(actor.id, native.content);
+    }
+    async handleFeishuMessage(message) {
+        if (this.isOwner(message.senderId)) {
+            this.nativeMessages.set(message.messageId, { ...message });
+            if (this.nativeMessages.size > 1000)
+                this.nativeMessages.delete(this.nativeMessages.keys().next().value);
+        }
+        const command = parseDeploymentCommand(message.content);
+        const pairing = /^开启安全发布 ([A-Za-z0-9_-]+)$/.exec(message.content.trim());
+        if (!command && !pairing)
+            return undefined;
+        if (pairing) {
+            // All operations stay synchronous, so competing inbound events cannot bind twice.
+            const config = this.readConfig();
+            if (!config || config.ownerOpenId || !config.pairingNonce || pairing[1] !== config.pairingNonce || !message.senderId.startsWith("ou_")) {
+                return "绑定未通过，请使用主机安装时给出的有效绑定口令。";
+            }
+            const next = { ...config, ownerOpenId: message.senderId };
+            delete next.pairingNonce;
+            const temporary = `${this.configPath}.${process.pid}.tmp`;
+            fs.writeFileSync(temporary, JSON.stringify(next, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+            fs.renameSync(temporary, this.configPath);
+            return "已绑定安全发布负责人。可以发送“准备发布”或“发布状态”。";
+        }
+        return this.command(command, { actorId: message.senderId, chatId: message.chatId, messageId: message.messageId });
+    }
+}
+/** Mount on the existing authenticated Bridge app; no new listening socket. */
+export function mountDeploymentRoutes(app, service, store) {
+    app.get("/deploy/readiness", (c) => c.json(service.readiness()));
+    app.post("/deploy/command", async (c) => {
+        const body = await c.req.json().catch(() => null);
+        if (!body?.runId || !["prepare", "publish", "status", "cancel", "rollback"].includes(body.action)) {
+            return c.json({ error: "invalid_deployment_command" }, 400);
+        }
+        const run = store.getRun(body.runId);
+        const turn = run?.turnId ? store.getTurn(run.turnId) : undefined;
+        const delivery = turn ? store.listDeliveries("feishu").find((item) => item.turnId === turn.turnId && item.runId === run?.id) : undefined;
+        const actor = turn?.message.actorRef;
+        if (!run || run.status !== "running" || !delivery || actor?.channel !== "feishu" || !service.isOwner(actor.id)) {
+            return c.json({ error: "owner_feishu_run_required" }, 403);
+        }
+        const native = service.nativeContext(delivery.replyToMessageId);
+        if (!native || native.senderId !== actor.id || native.chatId !== delivery.conversationId.split("|")[0]) {
+            return c.json({ error: "native_feishu_context_required" }, 403);
+        }
+        if ((body.action === "publish" || body.publishAfterPrepare === true) && !hasPublishIntent(native.content)) {
+            return c.json({ error: "explicit_publish_intent_required" }, 403);
+        }
+        if (body.action === "rollback" && parseDeploymentCommand(native.content)?.action !== "rollback") {
+            return c.json({ error: "explicit_rollback_intent_required" }, 403);
+        }
+        const command = { action: body.action };
+        if (typeof body.ref === "string")
+            command.ref = body.ref;
+        if (typeof body.releaseId === "string")
+            command.releaseId = body.releaseId;
+        if (typeof body.publishAfterPrepare === "boolean")
+            command.publishAfterPrepare = body.publishAfterPrepare;
+        const message = await service.command(command, {
+            actorId: actor.id,
+            chatId: native.chatId,
+            messageId: delivery.replyToMessageId,
+        });
+        return c.json({ message });
+    });
+}
+//# sourceMappingURL=deployment.js.map

package/node_modules/@codebridge/bridge/dist/event-loop-lag.d.ts

@@ -0,0 +1,19 @@
+/** 纯函数：给定两次 tick 之间的实际耗时，判断是否构成一次事件循环停顿告警。 */
+export declare function detectEventLoopStall(actualElapsedMs: number, expectedElapsedMs?: number, thresholdMs?: number): {
+    stalled: boolean;
+    lagMs: number;
+};
+/**
+ * 每秒检测一次事件循环是否被同步任务阻塞。心跳续租和 recovery 扫描都依赖
+ * 事件循环按时运转；一旦停顿超过阈值，先记录下来，方便定位「租约看似过期
+ * 但进程其实一直健康」这类假死场景的根因。
+ */
+export declare function startEventLoopLagMonitor(options?: {
+    now?: () => number;
+    warn?: (line: string) => void;
+    intervalMs?: number;
+    thresholdMs?: number;
+}): {
+    stop: () => void;
+};
+//# sourceMappingURL=event-loop-lag.d.ts.map

package/node_modules/@codebridge/bridge/dist/event-loop-lag.js

@@ -0,0 +1,33 @@
+const CHECK_INTERVAL_MS = 1_000;
+const STALL_THRESHOLD_MS = 5_000;
+/** 纯函数：给定两次 tick 之间的实际耗时，判断是否构成一次事件循环停顿告警。 */
+export function detectEventLoopStall(actualElapsedMs, expectedElapsedMs = CHECK_INTERVAL_MS, thresholdMs = STALL_THRESHOLD_MS) {
+    const lagMs = actualElapsedMs - expectedElapsedMs;
+    return { stalled: lagMs >= thresholdMs, lagMs };
+}
+/**
+ * 每秒检测一次事件循环是否被同步任务阻塞。心跳续租和 recovery 扫描都依赖
+ * 事件循环按时运转；一旦停顿超过阈值，先记录下来，方便定位「租约看似过期
+ * 但进程其实一直健康」这类假死场景的根因。
+ */
+export function startEventLoopLagMonitor(options = {}) {
+    const now = options.now ?? (() => Date.now());
+    const warn = options.warn ?? ((line) => console.warn(line));
+    const intervalMs = options.intervalMs ?? CHECK_INTERVAL_MS;
+    const thresholdMs = options.thresholdMs ?? STALL_THRESHOLD_MS;
+    let lastTick = now();
+    const timer = setInterval(() => {
+        const current = now();
+        const actualElapsedMs = current - lastTick;
+        lastTick = current;
+        const { stalled, lagMs } = detectEventLoopStall(actualElapsedMs, intervalMs, thresholdMs);
+        if (stalled) {
+            warn(`${new Date().toISOString()} event_loop_stall lagMs=${lagMs}`);
+        }
+    }, intervalMs);
+    timer.unref?.();
+    return {
+        stop: () => clearInterval(timer),
+    };
+}
+//# sourceMappingURL=event-loop-lag.js.map

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

@@ -0,0 +1,70 @@
+import { type AppConfig } from "@codebridge/core";
+import type { FeishuAlertMessage, FeishuAlertPage, FeishuAlertReply, FeishuMessage, FeishuAlertReaction } from "@codebridge/channel-feishu";
+type MonitorConfig = NonNullable<AppConfig["feishu"]["alertMonitor"]>;
+export interface FeishuAlertTransport {
+    readAlertDone?(messageId: string, after?: number): Promise<FeishuAlertReaction | undefined>;
+    /** Root message of the thread a message belongs to, so reactions on any thread message map to the incident. */
+    resolveAlertThreadRoot?(messageId: string): Promise<{
+        chatId: string;
+        rootId: string;
+    } | undefined>;
+    readAlertMessages(chatId: string, startTime: number, endTime: number, pageToken?: string): Promise<FeishuAlertPage>;
+    investigateAlert(alert: FeishuAlertMessage, approverOpenIds: string[], instructions: string): Promise<void>;
+    isAlertActive(chatId: string, rootId: string): Promise<boolean>;
+    cancelAlertInvestigation?(chatId: string, rootId: string): Promise<void>;
+    setAlertMessageReaction?(messageId: string, emojiType: string, managed: string[]): Promise<string>;
+    notifyAlertOwner?(chatId: string, rootId: string, approverOpenIds: string[], text: string): Promise<void>;
+    /** Plain reply in the alert thread, no mentions. */
+    postAlertThreadNotice?(chatId: string, rootId: string, text: string): Promise<void>;
+    /** Display name of a chat member; undefined when unknown. */
+    alertMemberName?(chatId: string, openId: string): Promise<string | undefined>;
+}
+export declare const ALERT_INVESTIGATION_INSTRUCTIONS: string;
+/** Owns polling checkpoints, duplicate suppression and the alert conversation approvers. */
+export declare class FeishuAlertMonitor {
+    private readonly options;
+    private readonly store;
+    private timer?;
+    private running?;
+    private stopped;
+    private readonly statusWrites;
+    constructor(options: {
+        statePath: string;
+        config: () => MonitorConfig | undefined;
+        transport: FeishuAlertTransport;
+        isMaintenance?: () => boolean;
+        now?: () => number;
+        log: (message: string) => void;
+    });
+    start(): void;
+    stop(): Promise<void>;
+    tick(): Promise<void>;
+    private poll;
+    private readGroup;
+    private accept;
+    private updateIncident;
+    /**
+     * Called before normal slash commands or Agent dispatch. Anyone may talk in an alert thread, close it or reopen it;
+     * only approvers can authorize write actions, which the Agent learns from the tagged speaker identity.
+     */
+    prepareReply(message: FeishuMessage, topicId: string | undefined): Promise<FeishuAlertReply | undefined>;
+    prepareReaction(reaction: FeishuAlertReaction): Promise<void>;
+    /** Cards, human replies and (via the thread root) the bot's own replies all belong to the incident. */
+    private incidentForMessage;
+    private reconcileOwnerReactions;
+    private statusEmoji;
+    private alertFingerprint;
+    private reactionInstructions;
+    private historyInstructions;
+    private dismissIncident;
+    private postDismissalReceipt;
+    private runbookInstructions;
+    setStatus(chatId: string, rootId: string, status: string, summary: string): Promise<void>;
+    private syncStatus;
+    private projectStatus;
+    /** Terminal incidents eventually stop shaping their thread, so old alert topics behave like ordinary ones again. */
+    private purgeExpiredIncidents;
+    isAlertMessage(chatId: string, messageId: string): boolean;
+}
+export {};
+//# sourceMappingURL=feishu-alert-monitor.d.ts.map