@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/bridge/dist/outbound-api.d.ts

@@ -0,0 +1,31 @@
+import { Hono } from "hono";
+import { type SqliteEventStore } from "@codebridge/work-items";
+import { type OutboundPublisher } from "./outbound-publishers.js";
+import type { ApprovalService } from "@codebridge/policy";
+import type { RunExecutor } from "@codebridge/run-executor";
+/** 出站 API 依赖的最小 Bridge 能力面 */
+export interface OutboundBridge {
+    setOutboundAlertStatus?(chatId: string, topicId: string, status: string, summary: string): Promise<void>;
+    sendOutboundFile(chatId: string, rawPath: string, topicId?: string): Promise<string>;
+    sendOutboundMarkdown(chatId: string, markdown: string, topicId?: string): Promise<void>;
+    sendOutboundMention(chatId: string, ref: string, text: string, topicId?: string): Promise<void>;
+}
+interface OutboundAppOptions {
+    publicPathPrefixes?: string[];
+    workItemStore?: SqliteEventStore;
+    publishers?: () => OutboundPublisher[];
+}
+/** 装配出站能力、兼容 TaskRecord API 和 Session-first API，共享同一个本地 Bearer Token。 */
+export declare function createBridgeApp(bridge: OutboundBridge, token: string, workItemStore: SqliteEventStore, approvalService?: ApprovalService, executor?: RunExecutor, projectCatalogApp?: Hono, webWorkbenchApp?: Hono, sessionCatalogApp?: Hono, mcpApp?: Hono, skillApp?: Hono, publishers?: () => OutboundPublisher[]): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+/** Resolve only the current Run's persisted delivery; never infer a recipient from an ID prefix. */
+export declare function resolveOutboundTarget(store: SqliteEventStore, runId: string): {
+    chatId: string;
+    topicId: string | undefined;
+};
+/**
+ * Bridge 本地出站 API：Agent 子进程内的 fcb 命令通过它把文件/消息发回飞书。
+ * 仅监听 127.0.0.1，Bearer 复用 runner token。
+ */
+export declare function createOutboundApp(bridge: OutboundBridge, token: string, options?: OutboundAppOptions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export {};
+//# sourceMappingURL=outbound-api.d.ts.map

package/node_modules/@codebridge/bridge/dist/outbound-api.js

@@ -0,0 +1,184 @@
+import { Hono } from "hono";
+import { createWorkItemApp } from "./work-item-api.js";
+import { OUTBOUND_ROUTES } from "./outbound-publishers.js";
+/** 装配出站能力、兼容 TaskRecord API 和 Session-first API，共享同一个本地 Bearer Token。 */
+export function createBridgeApp(bridge, token, workItemStore, approvalService, executor, projectCatalogApp, webWorkbenchApp, sessionCatalogApp, mcpApp, skillApp, publishers) {
+    const app = createOutboundApp(bridge, token, {
+        workItemStore,
+        publishers,
+        publicPathPrefixes: webWorkbenchApp ? ["/workbench"] : [],
+    });
+    app.route("/", createWorkItemApp(workItemStore, token, approvalService, executor));
+    if (sessionCatalogApp)
+        app.route("/", sessionCatalogApp);
+    if (mcpApp)
+        app.route("/", mcpApp);
+    if (skillApp)
+        app.route("/", skillApp);
+    if (projectCatalogApp)
+        app.route("/", projectCatalogApp);
+    if (webWorkbenchApp) {
+        app.route("/workbench", webWorkbenchApp);
+        app.route("/workbench/", webWorkbenchApp);
+    }
+    return app;
+}
+/** 把 /outbound/<name> 映射成路由名；不是已知出站路由时返回 undefined。 */
+function outboundRouteOf(requestPath) {
+    const prefix = "/outbound/";
+    if (!requestPath.startsWith(prefix))
+        return undefined;
+    const name = requestPath.slice(prefix.length);
+    return OUTBOUND_ROUTES.includes(name) ? name : undefined;
+}
+/** Resolve only the current Run's persisted delivery; never infer a recipient from an ID prefix. */
+export function resolveOutboundTarget(store, runId) {
+    const run = store.getRun(runId);
+    if (!run || run.status !== "running" || !run.turnId) {
+        throw new Error("outbound_active_run_required：请在当前 CodeBridge 任务内发送文件");
+    }
+    const deliveries = ["feishu", "telegram"].flatMap((channel) => store.listDeliveries(channel).filter((row) => row.runId === run.id && row.turnId === run.turnId)
+        .map((row) => ({ channel, conversationId: row.conversationId })));
+    const targets = [...new Map(deliveries.map((row) => [`${row.channel}:${row.conversationId}`, row])).values()];
+    if (targets.length !== 1) {
+        throw new Error("outbound_source_required：当前任务没有唯一的聊天来源，请从目标聊天窗口重新发起任务");
+    }
+    const target = targets[0];
+    const [chatId, topicId, extra] = target.conversationId.split("|");
+    if (extra !== undefined || !chatId || !(target.channel === "feishu"
+        ? /^oc_[A-Za-z0-9]+$/.test(chatId)
+        : /^telegram:-?\d+$/.test(chatId))) {
+        throw new Error("outbound_invalid_destination：任务来源不是有效的通道聊天 ID");
+    }
+    return { chatId, topicId: topicId || undefined };
+}
+/**
+ * Bridge 本地出站 API：Agent 子进程内的 fcb 命令通过它把文件/消息发回飞书。
+ * 仅监听 127.0.0.1，Bearer 复用 runner token。
+ */
+export function createOutboundApp(bridge, token, options = {}) {
+    const app = new Hono();
+    const resolvedTargets = new WeakMap();
+    const publicPathPrefixes = options.publicPathPrefixes ?? [];
+    const publishers = options.publishers ?? (() => []);
+    app.use("*", async (c, next) => {
+        const isPublicPath = publicPathPrefixes.some((prefix) => c.req.path === prefix || c.req.path.startsWith(`${prefix}/`));
+        if (isPublicPath) {
+            await next();
+            return;
+        }
+        const auth = c.req.header("authorization");
+        if (auth === `Bearer ${token}`) {
+            await next();
+            return;
+        }
+        // 发布者凭据只认已知的 /outbound/<route>，且收件人只取配置里写死的那一个：
+        // 请求体给出的 chatId 依旧会被覆盖，发送方无法自己选收件人。
+        const route = outboundRouteOf(c.req.path);
+        const publisher = route
+            ? publishers().find((row) => auth === `Bearer ${row.token}`)
+            : undefined;
+        if (!publisher || !route) {
+            return c.json({ error: "unauthorized" }, 401);
+        }
+        if (!publisher.routes.includes(route)) {
+            return c.json({ error: `outbound_route_forbidden：${publisher.label} 未获授权发送 ${route}` }, 403);
+        }
+        resolvedTargets.set(c.req.raw, {
+            chatId: publisher.chatId,
+            topicId: publisher.topicId,
+        });
+        await next();
+    });
+    app.use("/outbound/*", async (c, next) => {
+        // 发布者的收件人已在鉴权时定死，不需要也不可能有 runId。
+        if (!options.workItemStore || resolvedTargets.has(c.req.raw)) {
+            await next();
+            return;
+        }
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.runId !== "string" || !body.runId) {
+            return c.json({ error: "outbound_run_required：请使用当前任务的 fcb，发送目标由 Bridge 自动解析" }, 400);
+        }
+        try {
+            const target = resolveOutboundTarget(options.workItemStore, body.runId);
+            resolvedTargets.set(c.req.raw, target);
+        }
+        catch (error) {
+            return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+        }
+        await next();
+    });
+    app.post("/outbound/alert-status", async (c) => {
+        // This route is deliberately absent from publisher routes: only an active Run can set a status.
+        const target = resolvedTargets.get(c.req.raw);
+        if (!options.workItemStore || !target?.topicId || !target.chatId.startsWith("oc_")) {
+            return c.json({ error: "alert_status_requires_feishu_run" }, 400);
+        }
+        const body = await c.req.json().catch(() => null);
+        if (typeof body?.status !== "string" || typeof body.summary !== "string")
+            return c.json({ error: "status and summary required" }, 400);
+        try {
+            if (!bridge.setOutboundAlertStatus)
+                throw new Error("alert_status_unavailable");
+            await bridge.setOutboundAlertStatus(target.chatId, target.topicId, body.status, body.summary);
+            return c.json({ ok: true });
+        }
+        catch (error) {
+            return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+        }
+    });
+    app.post("/outbound/file", async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        const target = resolvedTargets.get(c.req.raw);
+        if (body && target)
+            Object.assign(body, target);
+        if (!body?.chatId || !body?.path) {
+            return c.json({ error: "chatId 和 path 必填" }, 400);
+        }
+        try {
+            const fileName = await bridge.sendOutboundFile(body.chatId, body.path, body.topicId);
+            return c.json({ ok: true, fileName });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 400);
+        }
+    });
+    app.post("/outbound/markdown", async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        const target = resolvedTargets.get(c.req.raw);
+        if (body && target)
+            Object.assign(body, target);
+        if (!body?.chatId || !body?.markdown) {
+            return c.json({ error: "chatId 和 markdown 必填" }, 400);
+        }
+        try {
+            await bridge.sendOutboundMarkdown(body.chatId, body.markdown, body.topicId);
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 400);
+        }
+    });
+    app.post("/outbound/mention", async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        const target = resolvedTargets.get(c.req.raw);
+        if (body && target)
+            Object.assign(body, target);
+        if (!body?.chatId || !body?.ref || !body?.text) {
+            return c.json({ error: "chatId、ref 和 text 必填" }, 400);
+        }
+        try {
+            await bridge.sendOutboundMention(body.chatId, body.ref, body.text, body.topicId);
+            return c.json({ ok: true });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            return c.json({ error: message }, 400);
+        }
+    });
+    return app;
+}
+//# sourceMappingURL=outbound-api.js.map

package/node_modules/@codebridge/bridge/dist/outbound-publishers.d.ts

@@ -0,0 +1,54 @@
+/** 出站路由名，与 /outbound/<name> 一一对应。 */
+export declare const OUTBOUND_ROUTES: readonly ["file", "markdown", "mention"];
+export type OutboundRoute = (typeof OUTBOUND_ROUTES)[number];
+/** 省略 routes 时的最小授权：能说话，不能外发文件。 */
+export declare const DEFAULT_ROUTES: OutboundRoute[];
+/**
+ * 出站发布者：本地定时任务一类的非 Agent 发送方。
+ *
+ * 它保证的是三件事：收件人在配置期由人写死、运行期任何发送方都改不了；
+ * 每条凭据只能用它被授权的那几个路由；以及 runner token 依旧必须带 runId，
+ * Agent 不会因为这条路径而被放行。
+ *
+ * 它不保证 Agent 永远拿不到该凭据：Agent 子进程与 Bridge 同一个系统用户，
+ * 能读文件就能读到它。0600 只挡其他用户。真正的隔离要靠沙箱，这里没有。
+ */
+export interface OutboundPublisher {
+    label: string;
+    token: string;
+    chatId: string;
+    topicId?: string;
+    routes: OutboundRoute[];
+}
+export declare const PUBLISHERS_FILE = "publisher-tokens.json";
+export declare function publishersPath(dataDir: string): string;
+/**
+ * 读取 <dataDir>/publisher-tokens.json。文件缺失表示没有配置发布者；
+ * 文件存在但内容不合法时抛错，不把一条静默失效的凭据当成已生效。
+ */
+export declare function loadOutboundPublishers(dataDir: string, runnerToken: string): OutboundPublisher[];
+/** 签发一条新凭据；同名 label 视为轮换，旧 token 立即作废。 */
+export declare function addPublisher(dataDir: string, runnerToken: string, entry: {
+    label: string;
+    chatId: string;
+    topicId?: string;
+    routes?: OutboundRoute[];
+}): OutboundPublisher;
+/** 列出已登记的发布者，永不返回 token 本身。 */
+export declare function listPublishers(dataDir: string, runnerToken: string): Array<Omit<OutboundPublisher, "token">>;
+/** 吊销一条凭据；返回是否真的删掉了。 */
+export declare function revokePublisher(dataDir: string, runnerToken: string, label: string): boolean;
+/**
+ * 按文件指纹热加载：签发或吊销后无需重启 Bridge，下一次请求即生效。
+ * 文件读坏时保留上一份可用凭据并上报一次，避免一个笔误就让投递全断。
+ */
+export declare class OutboundPublisherStore {
+    private readonly dataDir;
+    private readonly runnerToken;
+    private readonly onError;
+    private cache;
+    private fingerprint;
+    constructor(dataDir: string, runnerToken: string, onError?: (error: Error) => void);
+    current(): OutboundPublisher[];
+}
+//# sourceMappingURL=outbound-publishers.d.ts.map

package/node_modules/@codebridge/bridge/dist/outbound-publishers.js

@@ -0,0 +1,213 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+/** 出站路由名，与 /outbound/<name> 一一对应。 */
+export const OUTBOUND_ROUTES = ["file", "markdown", "mention"];
+/** 省略 routes 时的最小授权：能说话，不能外发文件。 */
+export const DEFAULT_ROUTES = ["markdown", "mention"];
+export const PUBLISHERS_FILE = "publisher-tokens.json";
+const CHAT_ID_PATTERN = /^(oc_[A-Za-z0-9]+|telegram:-?\d+)$/;
+const MIN_TOKEN_LENGTH = 24;
+export function publishersPath(dataDir) {
+    return path.join(dataDir, PUBLISHERS_FILE);
+}
+function invalid(file, index, reason) {
+    return new Error(`${file} 第 ${index + 1} 条发布者${reason}`);
+}
+function parseRoutes(file, index, value) {
+    if (value === undefined)
+        return [...DEFAULT_ROUTES];
+    if (!Array.isArray(value) || value.length === 0) {
+        throw invalid(file, index, "的 routes 必须是非空数组");
+    }
+    for (const route of value) {
+        if (!OUTBOUND_ROUTES.includes(route)) {
+            throw invalid(file, index, `的 routes 含未知路由 ${JSON.stringify(route)}`);
+        }
+    }
+    return [...new Set(value)];
+}
+/**
+ * 读取 <dataDir>/publisher-tokens.json。文件缺失表示没有配置发布者；
+ * 文件存在但内容不合法时抛错，不把一条静默失效的凭据当成已生效。
+ */
+export function loadOutboundPublishers(dataDir, runnerToken) {
+    const file = publishersPath(dataDir);
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    if ((fs.statSync(file).mode & 0o077) !== 0) {
+        throw new Error(`${file} 对同组或其他用户可读，请先 chmod 600`);
+    }
+    const entries = JSON.parse(raw);
+    if (!Array.isArray(entries))
+        throw new Error(`${file} 必须是发布者数组`);
+    const seen = new Set();
+    return entries.map((value, index) => {
+        const entry = (value ?? {});
+        if (typeof entry.label !== "string" || !entry.label.trim()) {
+            throw invalid(file, index, "缺少 label");
+        }
+        if (typeof entry.token !== "string" || entry.token.length < MIN_TOKEN_LENGTH) {
+            throw invalid(file, index, `的 token 少于 ${MIN_TOKEN_LENGTH} 位`);
+        }
+        if (entry.token === runnerToken) {
+            throw invalid(file, index, "不能复用 runner token，否则 Agent 也能拿到它");
+        }
+        if (seen.has(entry.token))
+            throw invalid(file, index, "的 token 与前面的重复");
+        seen.add(entry.token);
+        if (typeof entry.chatId !== "string" || !CHAT_ID_PATTERN.test(entry.chatId)) {
+            throw invalid(file, index, "的 chatId 不是有效的通道聊天 ID");
+        }
+        if (entry.topicId !== undefined && typeof entry.topicId !== "string") {
+            throw invalid(file, index, "的 topicId 必须是字符串");
+        }
+        return {
+            label: entry.label,
+            token: entry.token,
+            chatId: entry.chatId,
+            topicId: entry.topicId || undefined,
+            routes: parseRoutes(file, index, entry.routes),
+        };
+    });
+}
+const LOCK_STALE_MS = 60_000;
+/** 等锁多久放弃；测试用环境变量调短，生产不设置即 5 秒。 */
+function lockTimeoutMs() {
+    return Number(process.env.CODEBRIDGE_PUBLISHER_LOCK_TIMEOUT_MS ?? 5_000);
+}
+/**
+ * 串行化"读全量→改→整份写回"，否则两个并发的 add 会互相吞掉对方新签的凭据。
+ * 锁文件带时间戳，进程崩溃留下的陈旧锁到点自动接管，不会把后续签发永久卡死。
+ */
+function withPublisherLock(dataDir, action) {
+    const lock = `${publishersPath(dataDir)}.lock`;
+    fs.mkdirSync(path.dirname(lock), { recursive: true, mode: 0o700 });
+    const deadline = Date.now() + lockTimeoutMs();
+    let handle;
+    while (handle === undefined) {
+        try {
+            handle = fs.openSync(lock, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 0o600);
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const age = Date.now() - (fs.statSync(lock, { throwIfNoEntry: false })?.mtimeMs ?? Date.now());
+            if (age > LOCK_STALE_MS) {
+                fs.rmSync(lock, { force: true });
+                continue;
+            }
+            if (Date.now() > deadline) {
+                throw new Error(`${lock} 正被另一个进程占用，请稍后重试`);
+            }
+            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 20);
+        }
+    }
+    try {
+        return action();
+    }
+    finally {
+        fs.closeSync(handle);
+        fs.rmSync(lock, { force: true });
+    }
+}
+function writePublishers(dataDir, entries) {
+    const file = publishersPath(dataDir);
+    fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+    // 每个写入者用自己的临时名，免得并发写互相踩，也免得崩溃残留被下一个写入者接手。
+    const temporary = `${file}.${process.pid}.${crypto.randomBytes(4).toString("hex")}.tmp`;
+    const payload = entries.map((entry) => ({
+        label: entry.label,
+        token: entry.token,
+        chatId: entry.chatId,
+        ...(entry.topicId ? { topicId: entry.topicId } : {}),
+        routes: entry.routes,
+    }));
+    fs.writeFileSync(temporary, `${JSON.stringify(payload, null, 2)}\n`, { mode: 0o600 });
+    fs.chmodSync(temporary, 0o600);
+    fs.renameSync(temporary, file);
+}
+/** 签发一条新凭据；同名 label 视为轮换，旧 token 立即作废。 */
+export function addPublisher(dataDir, runnerToken, entry) {
+    if (!entry.label.trim())
+        throw new Error("label 不能为空");
+    if (!CHAT_ID_PATTERN.test(entry.chatId))
+        throw new Error("chatId 不是有效的通道聊天 ID");
+    for (const route of entry.routes ?? []) {
+        if (!OUTBOUND_ROUTES.includes(route))
+            throw new Error(`未知路由 ${route}`);
+    }
+    const issued = {
+        label: entry.label,
+        token: crypto.randomBytes(24).toString("hex"),
+        chatId: entry.chatId,
+        topicId: entry.topicId || undefined,
+        routes: entry.routes?.length ? [...new Set(entry.routes)] : [...DEFAULT_ROUTES],
+    };
+    withPublisherLock(dataDir, () => {
+        const kept = loadOutboundPublishers(dataDir, runnerToken).filter((row) => row.label !== entry.label);
+        writePublishers(dataDir, [...kept, issued]);
+    });
+    return issued;
+}
+/** 列出已登记的发布者，永不返回 token 本身。 */
+export function listPublishers(dataDir, runnerToken) {
+    return loadOutboundPublishers(dataDir, runnerToken).map(({ token: _token, ...rest }) => rest);
+}
+/** 吊销一条凭据；返回是否真的删掉了。 */
+export function revokePublisher(dataDir, runnerToken, label) {
+    return withPublisherLock(dataDir, () => {
+        const entries = loadOutboundPublishers(dataDir, runnerToken);
+        const kept = entries.filter((row) => row.label !== label);
+        if (kept.length === entries.length)
+            return false;
+        writePublishers(dataDir, kept);
+        return true;
+    });
+}
+/**
+ * 按文件指纹热加载：签发或吊销后无需重启 Bridge，下一次请求即生效。
+ * 文件读坏时保留上一份可用凭据并上报一次，避免一个笔误就让投递全断。
+ */
+export class OutboundPublisherStore {
+    dataDir;
+    runnerToken;
+    onError;
+    cache = [];
+    fingerprint;
+    constructor(dataDir, runnerToken, onError = () => { }) {
+        this.dataDir = dataDir;
+        this.runnerToken = runnerToken;
+        this.onError = onError;
+    }
+    current() {
+        let fingerprint = "";
+        try {
+            const stats = fs.statSync(publishersPath(this.dataDir));
+            fingerprint = `${stats.mtimeMs}:${stats.size}:${stats.ino}`;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                fingerprint = `unreadable:${String(error.code)}`;
+            }
+        }
+        if (fingerprint === this.fingerprint)
+            return this.cache;
+        this.fingerprint = fingerprint;
+        try {
+            this.cache = loadOutboundPublishers(this.dataDir, this.runnerToken);
+        }
+        catch (error) {
+            this.onError(error instanceof Error ? error : new Error(String(error)));
+        }
+        return this.cache;
+    }
+}
+//# sourceMappingURL=outbound-publishers.js.map

package/node_modules/@codebridge/bridge/dist/project-api.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { ProjectCatalogGitRepository, ProjectCatalogStore, ProjectDiscovery } from "@codebridge/project-catalog";
+export declare function createProjectCatalogApp(catalog: ProjectCatalogStore, discovery: ProjectDiscovery, token: string, gitRepository?: ProjectCatalogGitRepository): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=project-api.d.ts.map

package/node_modules/@codebridge/bridge/dist/project-api.js

@@ -0,0 +1,161 @@
+import { Hono } from "hono";
+export function createProjectCatalogApp(catalog, discovery, token, gitRepository) {
+    const app = new Hono();
+    app.use("/v1/*", async (c, next) => {
+        if (c.req.header("authorization") !== `Bearer ${token}`) {
+            return c.json({ error: { code: "unauthorized", message: "未授权" } }, 401);
+        }
+        await next();
+    });
+    app.get("/v1/projects/candidates", (c) => c.json({ candidates: catalog.listCandidates().map(toApiCandidate) }));
+    app.get("/v1/projects", (c) => c.json({ projects: catalog.listProjects().map(toApiProject) }));
+    app.get("/v1/projects/drifts", (c) => {
+        const projectId = c.req.query("project_id");
+        return c.json({ drifts: catalog.listDrifts(projectId || undefined) });
+    });
+    app.post("/v1/projects/candidates/:candidate_id/proposals", async (c) => {
+        if (!gitRepository)
+            return c.json({ error: { code: "catalog_git_unavailable", message: "Project catalog Git 未配置" } }, 503);
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.branch !== "string" || !body.branch.trim()) {
+            return c.json({ error: { code: "invalid_catalog_proposal", message: "branch 必填" } }, 400);
+        }
+        try {
+            const projects = catalog.projectsForCandidate(c.req.param("candidate_id"));
+            return c.json(gitRepository.createProposal(projects, {
+                branch: body.branch,
+                message: typeof body.message === "string" ? body.message : undefined,
+            }), 201);
+        }
+        catch (error) {
+            const message = messageOf(error);
+            const code = message.includes("not found") ? "candidate_not_found" : "catalog_proposal_failed";
+            return c.json({ error: { code, message } }, code === "candidate_not_found" ? 404 : 409);
+        }
+    });
+    app.post("/v1/projects/catalog/sync", async (c) => {
+        if (!gitRepository)
+            return c.json({ error: { code: "catalog_git_unavailable", message: "Project catalog Git 未配置" } }, 503);
+        const body = await c.req.json().catch(() => null);
+        const ref = typeof body?.ref === "string" && body.ref.trim() ? body.ref : undefined;
+        try {
+            const revision = ref ?? gitRepository.baseRef;
+            const projects = gitRepository.readProjects(ref);
+            return c.json({ revision, projects: catalog.syncProjects(projects, revision).map(toApiProject) });
+        }
+        catch (error) {
+            return c.json({ error: { code: "catalog_sync_failed", message: messageOf(error) } }, 409);
+        }
+    });
+    app.get("/v1/projects/candidates/:candidate_id/diff", (c) => {
+        try {
+            return c.json(catalog.previewCandidate(c.req.param("candidate_id")));
+        }
+        catch (error) {
+            return c.json({ error: { code: "candidate_not_found", message: messageOf(error) } }, 404);
+        }
+    });
+    app.post("/v1/projects/candidates/:candidate_id/accept", (c) => {
+        try {
+            return c.json(toApiProject(catalog.acceptCandidate(c.req.param("candidate_id"))), 201);
+        }
+        catch (error) {
+            return c.json({ error: { code: "candidate_not_found", message: messageOf(error) } }, 404);
+        }
+    });
+    app.post("/v1/projects/drifts/:drift_id/resolve", (c) => {
+        const drift = catalog.resolveDrift(c.req.param("drift_id"));
+        if (!drift)
+            return c.json({ error: { code: "drift_not_found", message: "Project drift 不存在" } }, 404);
+        return c.json({ drift });
+    });
+    app.post("/v1/projects/drifts/:drift_id/apply", (c) => {
+        const project = catalog.applyDrift(c.req.param("drift_id"));
+        if (!project)
+            return c.json({ error: { code: "drift_not_found", message: "Project drift 不存在或已处理" } }, 404);
+        return c.json({ project: toApiProject(project) });
+    });
+    app.post("/v1/discovery/tasks", async (c) => {
+        const body = (await c.req.json().catch(() => null));
+        if (!body || typeof body.workspace_path !== "string" || !body.workspace_path.trim()) {
+            return c.json({ error: { code: "invalid_discovery", message: "workspace_path 必填" } }, 400);
+        }
+        const task = catalog.createDiscoveryTask({
+            workspacePath: body.workspace_path,
+            workItemId: typeof body.work_item_id === "string" ? body.work_item_id : null,
+        });
+        launchTask(task);
+        return c.json({ task_id: task.id, status: task.status }, 202);
+    });
+    app.get("/v1/discovery/tasks/:task_id", (c) => {
+        const task = catalog.getDiscoveryTask(c.req.param("task_id"));
+        if (!task)
+            return c.json({ error: { code: "task_not_found", message: "Discovery task 不存在" } }, 404);
+        return c.json(toApiTask(task));
+    });
+    for (const task of catalog.listDiscoveryTasks(["queued", "running"]))
+        launchTask(task);
+    return app;
+    function launchTask(task) {
+        catalog.updateDiscoveryTask(task.id, { status: "running", error: null });
+        void (async () => {
+            try {
+                const candidate = await discovery.observe(task.workspacePath, task.workItemId ?? undefined);
+                catalog.updateDiscoveryTask(task.id, { status: "succeeded", candidateId: candidate.id, error: null });
+            }
+            catch (error) {
+                catalog.updateDiscoveryTask(task.id, { status: "failed", error: messageOf(error) });
+            }
+        })();
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function toApiCandidate(candidate) {
+    return {
+        id: candidate.id,
+        project_id: candidate.projectId,
+        display_name: candidate.displayName,
+        repository_remote: candidate.repositoryRemote,
+        language: candidate.language,
+        deploy_service: candidate.deployService,
+        log_service: candidate.logService,
+        apm_service: candidate.apmService,
+        dependencies: candidate.dependencies ?? [],
+        confidence: candidate.confidence,
+        status: candidate.status,
+        evidence: candidate.evidence,
+        observed_at: candidate.observedAt,
+    };
+}
+function toApiTask(task) {
+    return {
+        task_id: task.id,
+        status: task.status,
+        workspace_path: task.workspacePath,
+        work_item_id: task.workItemId,
+        candidate_id: task.candidateId,
+        error: task.error,
+        created_at: task.createdAt,
+        updated_at: task.updatedAt,
+    };
+}
+function toApiProject(project) {
+    return {
+        id: project.id,
+        project_id: project.id,
+        display_name: project.displayName,
+        repository_remote: project.repositoryRemote,
+        language: project.language,
+        deploy_service: project.deployService,
+        log_service: project.logService,
+        apm_service: project.apmService,
+        dependencies: project.dependencies ?? [],
+        confidence: project.confidence,
+        status: project.status,
+        evidence: project.evidence,
+        registered_at: project.registeredAt,
+    };
+}
+//# sourceMappingURL=project-api.js.map

package/node_modules/@codebridge/bridge/dist/secrets-command.d.ts

@@ -0,0 +1,13 @@
+import { type SecretOptions } from "@codebridge/core";
+export interface SecretMigration {
+    migrated: string[];
+    /** Field name -> why it was left as is (already a ref, missing, placeholder). */
+    skipped: Record<string, string>;
+}
+/**
+ * Move plaintext secrets from config.yaml into the OS keychain and replace them with
+ * keychain: refs. Each secret is read back before the file changes; the file is rewritten
+ * once, atomically, keeping comments and layout.
+ */
+export declare function migrateConfigSecrets(configPath: string, options?: SecretOptions): SecretMigration;
+//# sourceMappingURL=secrets-command.d.ts.map