@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/core/dist/config-schema.js

@@ -0,0 +1,293 @@
+import { z } from "zod";
+/** Single source of truth for the npm ACP adapter package versions used as spawn defaults. */
+export const ACP_CLAUDE_AGENT_ACP_VERSION = "0.81.1";
+export const ACP_CODEX_ACP_VERSION = "1.13.1";
+export const PolicyScenarioSchema = z.object({
+    name: z.string(),
+    chats: z.array(z.string()),
+    requireMention: z.boolean().optional(),
+    enabled: z.boolean().optional(),
+});
+export const FeishuPolicySchema = z.object({
+    requireMention: z.boolean().default(true),
+    dmMode: z.enum(["open", "disabled", "allowlist", "pair"]).default("open"),
+    dmAllowlist: z.array(z.string()).optional(),
+    groupAllowlist: z.array(z.string()).optional(),
+    respondToMentionAll: z.boolean().default(false),
+    scenarios: z.array(PolicyScenarioSchema).optional(),
+});
+/** Web Rail / 飞书 `/backend` 共用的五家 Agent，不再扩张。 */
+export const SUPPORTED_AGENT_IDS = [
+    "cursor",
+    "claude",
+    "codex",
+    "pi",
+    "opencode",
+];
+export const BackendProfileSchema = z.object({
+    type: z.enum(["cursor-cli", "claude-code", "codex", "generic-spawn", "pi-sdk"]),
+    // 兼容旧配置里的显式 `transport: acp`；CLI transport 已移除；pi-sdk 不读取该字段。
+    transport: z.literal("acp").optional(),
+    acpCommand: z.string().optional(),
+    acpArgs: z.array(z.string()).optional(),
+    model: z.string().optional(),
+    effort: z.string().optional(),
+    /** true 时，若适配器未 advertise 想要的 model，本轮直接失败而非静默用适配器默认；默认 false */
+    strictModel: z.boolean().optional(),
+    /** Claude ACP mode 的兼容默认值，默认 bypassPermissions 避免 dontAsk 拒绝 Bash */
+    claudePermissionMode: z
+        .enum([
+        "acceptEdits",
+        "auto",
+        "bypassPermissions",
+        "default",
+        "dontAsk",
+        "plan",
+    ])
+        .optional(),
+});
+export const DEFAULT_BACKEND_PROFILES = {
+    cursor: {
+        type: "cursor-cli",
+        acpCommand: "cursor-agent",
+        acpArgs: ["acp"],
+    },
+    claude: {
+        type: "claude-code",
+        acpCommand: "npx",
+        acpArgs: ["-y", `@agentclientprotocol/claude-agent-acp@${ACP_CLAUDE_AGENT_ACP_VERSION}`],
+        claudePermissionMode: "bypassPermissions",
+    },
+    codex: {
+        type: "codex",
+        acpCommand: "npx",
+        acpArgs: ["-y", `@agentclientprotocol/codex-acp@${ACP_CODEX_ACP_VERSION}`],
+    },
+    pi: { type: "pi-sdk" },
+    opencode: {
+        type: "generic-spawn",
+        acpCommand: "opencode",
+        acpArgs: ["acp"],
+    },
+};
+function mergeDefaultBackends(backends) {
+    return { ...DEFAULT_BACKEND_PROFILES, ...backends };
+}
+export const AccessConfigSchema = z.object({
+    allowedUsers: z.array(z.string()).optional(),
+    allowedChats: z.array(z.string()).optional(),
+    admins: z.array(z.string()).optional(),
+});
+export const WorkspacesConfigSchema = z.object({
+    root: z.string().optional(),
+    default: z.string().optional(),
+    named: z.record(z.string()).optional(),
+});
+export const ProjectCatalogConfigSchema = z.object({
+    repositoryPath: z.string().min(1),
+    baseRef: z.string().min(1).default("main"),
+    catalogPath: z.string().min(1).default("catalog/projects.yaml"),
+});
+const McpServerCommonSchema = {
+    revision: z.string().min(1).optional(),
+    enabled: z.boolean().default(true),
+};
+export const McpServerConfigSchema = z.discriminatedUnion("transport", [
+    z.object({
+        transport: z.literal("stdio"),
+        command: z.string().min(1),
+        args: z.array(z.string()).optional(),
+        env: z.array(z.string().min(1)).optional(),
+        ...McpServerCommonSchema,
+    }),
+    z.object({
+        transport: z.literal("http"),
+        url: z.string().url(),
+        ...McpServerCommonSchema,
+    }),
+]);
+export const SessionAutoRotateConfigSchema = z.object({
+    /** Default on: a chat should not resume one provider session forever. */
+    enabled: z.boolean().optional(),
+    /** Start a fresh session when the last one has been idle this long; 0 disables. Default 12. */
+    idleHours: z.number().min(0).optional(),
+    /** Start a fresh session once the last reported context use reaches this share of the window. Default 0.5. */
+    maxContextRatio: z.number().gt(0).max(1).optional(),
+});
+export const SessionRuntimeConfigSchema = z.object({
+    maxQueuedTurns: z.number().int().min(1).max(1_000).default(100),
+    autoRotate: SessionAutoRotateConfigSchema.optional(),
+});
+export const OrchestrationConfigSchema = z.object({
+    projectCatalog: ProjectCatalogConfigSchema.optional(),
+    mcpServers: z.record(McpServerConfigSchema).optional(),
+    session: SessionRuntimeConfigSchema.optional(),
+});
+export const ConfigSchema = z.object({
+    feishu: z.object({
+        domain: z.string().url().default("https://open.feishu.cn"),
+        appId: z.string().min(1),
+        appSecret: z.string().min(1),
+        policy: FeishuPolicySchema.optional(),
+        alertMonitor: z.object({
+            enabled: z.boolean().optional(),
+            pollIntervalMs: z.number().int().min(5_000).max(300_000).default(30_000),
+            lookbackMs: z.number().int().min(1_000).max(86_400_000).default(600_000),
+            dedupWindowMs: z.number().int().min(1_000).max(86_400_000).default(1_800_000),
+            maxConcurrent: z.number().int().min(1).max(10).default(2),
+            /** Terminal incidents older than this leave the state file and stop shaping their thread. */
+            incidentRetentionMs: z.number().int().min(3_600_000).max(90 * 86_400_000).default(7 * 86_400_000),
+            statusReactions: z.object({
+                investigating: z.string().min(1), waiting: z.string().min(1), resolved: z.string().min(1),
+                no_action: z.string().min(1), blocked: z.string().min(1),
+            }).refine((mapping) => new Set(Object.values(mapping)).size === 5, "Alert statuses need distinct reactions").optional(),
+            groups: z.array(z.object({
+                chatId: z.string().regex(/^oc_/),
+                senderAppIds: z.array(z.string().min(1)).min(1),
+                /** Deprecated alias for a single approver; kept so existing configs load. */
+                ownerOpenId: z.string().regex(/^ou_/).optional(),
+                /** People who can authorize write actions. Anyone in the group can chat, close or reopen. */
+                approverOpenIds: z.array(z.string().regex(/^ou_/)).optional(),
+                runbookPath: z.string().min(1).optional(),
+            }).refine((group) => (group.approverOpenIds?.length ?? 0) > 0 || Boolean(group.ownerOpenId), "Alert group needs at least one approver")).min(1).refine((groups) => new Set(groups.map((group) => group.chatId)).size === groups.length, "Duplicate alert group"),
+        }).optional(),
+    }),
+    telegram: z
+        .object({
+        botToken: z.string().min(1),
+        allowedUsers: z.array(z.string()).optional(),
+        allowedChats: z.array(z.string()).optional(),
+        pollingTimeoutSec: z.number().int().min(1).max(50).default(25),
+    })
+        .optional(),
+    runner: z.object({
+        url: z.string().url().default("http://127.0.0.1:19789"),
+        token: z.string().min(8),
+    }),
+    web: z
+        .object({
+        /** The Web surface is opt-in; channels and Core API remain independent. */
+        enabled: z.boolean().default(false),
+        /** Optional absolute path to the built React application. */
+        staticDirectory: z.string().min(1).optional(),
+    })
+        .default({ enabled: false }),
+    defaultAgent: z.string().min(1).optional(),
+    defaultBackend: z.enum(SUPPORTED_AGENT_IDS).default("cursor"),
+    backends: z.record(BackendProfileSchema).transform(mergeDefaultBackends),
+    access: AccessConfigSchema.optional(),
+    workspaces: WorkspacesConfigSchema.optional(),
+    orchestration: OrchestrationConfigSchema.optional(),
+    runnerHost: z
+        .object({
+        listen: z.string().default("127.0.0.1:19789"),
+        maxConcurrentRuns: z.number().int().positive().default(4),
+        /** auto_allow=全放行；prompt_deny=一律拒绝；prompt_feishu=在飞书里等 /approve /deny（超时拒绝） */
+        acpPermissionPolicy: z
+            .enum(["auto_allow", "prompt_deny", "prompt_feishu"])
+            .default("auto_allow"),
+        /** 一轮无结束信号的总超时（ms）；长任务可运行 6 小时，和停滞检测分开 */
+        acpPromptTimeoutMs: z
+            .number()
+            .int()
+            .positive()
+            .default(6 * 60 * 60_000),
+        /** 从发 prompt 起完全无任何输出的超时（ms） */
+        acpNoOutputTimeoutMs: z
+            .number()
+            .int()
+            .positive()
+            .default(10 * 60_000),
+        /** 已有输出后无新事件的 stall 超时（ms），到点判 fatal（疑似工具卡死） */
+        acpStallTimeoutMs: z
+            .number()
+            .int()
+            .positive()
+            .default(30 * 60_000),
+        /** 主轮 stop 后续读后台子 agent 输出（drain）总开关 */
+        acpDrainBackgroundWork: z.boolean().default(true),
+        /** drain probe 短窗：主轮 stop 后这么久无真实后台活动则判无后台（ms） */
+        acpPostStopProbeMs: z.number().int().positive().default(8_000),
+        /** drain quiet 长窗：确认有后台后这么久无新活动视为后台结束（ms） */
+        acpPostStopQuietMs: z.number().int().positive().default(75_000),
+        /** drain 独立硬上限：后台跑这么久仍未结束则停止跟踪（ms） */
+        acpPostStopMaxMs: z.number().int().positive().default(20 * 60_000),
+        /** 长驻会话池总开关：同会话消息复用适配器进程，省每轮 2-4s 冷启动 */
+        acpSessionPool: z.boolean().default(true),
+        /** 池内空闲会话进程的回收时限（ms） */
+        acpSessionIdleMs: z
+            .number()
+            .int()
+            .positive()
+            .default(10 * 60_000),
+        /** 池内最多保留多少个空闲会话进程 */
+        acpSessionPoolMax: z.number().int().positive().default(4),
+    })
+        .optional(),
+    /** Bridge 本地出站 API（供 Agent 内的 fcb 命令把文件/消息发回飞书） */
+    bridge: z
+        .object({
+        apiPort: z.number().int().positive().default(19790),
+    })
+        .optional(),
+});
+/** Web 设置页的 defaultAgent 优先；没有再回退到 defaultBackend。 */
+export function resolveDefaultAgentId(config) {
+    const preferred = config.defaultAgent?.trim();
+    if (preferred && config.backends[preferred])
+        return preferred;
+    if (config.defaultBackend && config.backends[config.defaultBackend]) {
+        return config.defaultBackend;
+    }
+    for (const id of SUPPORTED_AGENT_IDS) {
+        if (config.backends[id])
+            return id;
+    }
+    return Object.keys(config.backends)[0] ?? "cursor";
+}
+export function isSupportedAgentId(id) {
+    return SUPPORTED_AGENT_IDS.includes(id);
+}
+export function defaultConfig() {
+    return ConfigSchema.parse({
+        feishu: {
+            domain: "https://open.feishu.cn",
+            appId: "cli_placeholder",
+            appSecret: "secret_placeholder",
+            policy: {
+                requireMention: true,
+                dmMode: "open",
+                respondToMentionAll: false,
+            },
+        },
+        runner: {
+            url: "http://127.0.0.1:19789",
+            token: "change-me-runner-token",
+        },
+        web: {
+            enabled: false,
+        },
+        defaultAgent: undefined,
+        defaultBackend: "cursor",
+        backends: DEFAULT_BACKEND_PROFILES,
+        workspaces: {
+            root: `${process.env.HOME ?? ""}/Projects`,
+        },
+    });
+}
+/** Resolve effective requireMention for a chat (scenarios override global). */
+export function resolveRequireMention(policy, chatId) {
+    const base = policy?.requireMention ?? true;
+    if (!policy?.scenarios?.length)
+        return base;
+    for (const scenario of policy.scenarios) {
+        if (!scenario.chats.includes(chatId))
+            continue;
+        if (scenario.enabled === false)
+            return false;
+        if (scenario.requireMention !== undefined)
+            return scenario.requireMention;
+    }
+    return base;
+}
+//# sourceMappingURL=config-schema.js.map

package/node_modules/@codebridge/core/dist/config-store.d.ts

@@ -0,0 +1,48 @@
+import { type AppConfig } from "./config-schema.js";
+import { type SecretOptions, type SecretSource } from "./secret-refs.js";
+export interface ConfigStoreOptions {
+    dataDir?: string;
+    configFileName?: string;
+    secrets?: SecretOptions;
+    /**
+     * Secret fields to resolve (e.g. ["runner.token"] for the Runner). Others keep their
+     * ref text, so a process never fails on a secret it does not use. Default: all.
+     */
+    resolve?: readonly string[];
+}
+export interface SecretInspection {
+    source: SecretSource;
+    /** Whether the value (ref or env override) can be read right now. */
+    readable: boolean;
+    error?: string;
+}
+export declare class ConfigStore {
+    private config;
+    private readonly configPath;
+    private readonly secretOptions;
+    private secrets;
+    private listeners;
+    constructor(options?: ConfigStoreOptions);
+    private readonly resolveFields?;
+    /**
+     * Per-field secret report that never throws, for doctor/status: a broken ref is a
+     * finding to show, not a reason to crash the diagnostic.
+     */
+    static inspectSecrets(configPath: string, options?: SecretOptions): Record<string, SecretInspection>;
+    /** Where each secret field comes from, as written on disk (no values). */
+    secretSources(): Record<string, SecretSource>;
+    /** The on-disk value of a secret field: a ref when one is configured. */
+    diskSecret(name: string): unknown;
+    get path(): string;
+    get(): AppConfig;
+    reload(): AppConfig;
+    save(partial: Partial<AppConfig>): AppConfig;
+    update(mutator: (current: AppConfig) => AppConfig): AppConfig;
+    onChange(listener: (config: AppConfig) => void): () => void;
+    private notify;
+    private persist;
+    private loadFromDisk;
+    private recordSecrets;
+    private loadFromEnv;
+}
+//# sourceMappingURL=config-store.d.ts.map

package/node_modules/@codebridge/core/dist/config-store.js

@@ -0,0 +1,207 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { ConfigSchema, defaultConfig, } from "./config-schema.js";
+import { DEFAULT_DATA_DIR } from "./types.js";
+import { SECRET_ENV_VARS, SECRET_PATHS, getPath, isSecretRef, resolveSecretRef, secretPathName, secretSourceOf, setPath, } from "./secret-refs.js";
+export class ConfigStore {
+    config;
+    configPath;
+    secretOptions;
+    secrets = new Map();
+    listeners = [];
+    constructor(options = {}) {
+        const dataDir = options.dataDir ?? process.env.DATA_DIR ?? DEFAULT_DATA_DIR;
+        this.configPath = path.join(dataDir, options.configFileName ?? "config.yaml");
+        this.secretOptions = options.secrets ?? {};
+        this.resolveFields = options.resolve;
+        this.config = this.loadFromDisk();
+    }
+    resolveFields;
+    /**
+     * Per-field secret report that never throws, for doctor/status: a broken ref is a
+     * finding to show, not a reason to crash the diagnostic.
+     */
+    static inspectSecrets(configPath, options = {}) {
+        const parsed = fs.existsSync(configPath)
+            ? (parseYaml(fs.readFileSync(configPath, "utf8")) ?? {})
+            : {};
+        const env = options.env ?? process.env;
+        return Object.fromEntries(SECRET_PATHS.map((secretPath) => {
+            const name = secretPathName(secretPath);
+            const value = getPath(parsed, secretPath);
+            const inspection = { source: secretSourceOf(value), readable: true };
+            if (env[SECRET_ENV_VARS[name]])
+                return [name, inspection];
+            if (isSecretRef(value)) {
+                try {
+                    resolveSecretRef(value, options);
+                }
+                catch (error) {
+                    inspection.readable = false;
+                    inspection.error = error instanceof Error ? error.message : String(error);
+                }
+            }
+            else if (inspection.source === "missing") {
+                inspection.readable = false;
+            }
+            return [name, inspection];
+        }));
+    }
+    /** Where each secret field comes from, as written on disk (no values). */
+    secretSources() {
+        return Object.fromEntries(SECRET_PATHS.map((secretPath) => {
+            const entry = this.secrets.get(secretPathName(secretPath));
+            return [secretPathName(secretPath), secretSourceOf(entry?.disk)];
+        }));
+    }
+    /** The on-disk value of a secret field: a ref when one is configured. */
+    diskSecret(name) {
+        return this.secrets.get(name)?.disk;
+    }
+    get path() {
+        return this.configPath;
+    }
+    get() {
+        return this.config;
+    }
+    reload() {
+        this.config = this.loadFromDisk();
+        this.notify();
+        return this.config;
+    }
+    save(partial) {
+        this.config = ConfigSchema.parse({ ...this.config, ...partial });
+        this.persist();
+        this.notify();
+        return this.config;
+    }
+    update(mutator) {
+        this.config = ConfigSchema.parse(mutator(this.config));
+        this.persist();
+        this.notify();
+        return this.config;
+    }
+    onChange(listener) {
+        this.listeners.push(listener);
+        return () => {
+            this.listeners = this.listeners.filter((l) => l !== listener);
+        };
+    }
+    notify() {
+        for (const l of this.listeners)
+            l(this.config);
+    }
+    persist() {
+        const dir = path.dirname(this.configPath);
+        if (!fs.existsSync(dir))
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        const existed = fs.existsSync(this.configPath);
+        const output = structuredClone(this.config);
+        for (const secretPath of SECRET_PATHS) {
+            const name = secretPathName(secretPath);
+            const entry = this.secrets.get(name);
+            const current = getPath(output, secretPath);
+            if (entry?.external && current === entry.loaded) {
+                // Unchanged value from a ref or env: write back what was on disk, never the secret.
+                // Env-only values become an env: ref so the file still loads where that env is set.
+                setPath(output, secretPath, entry.disk ?? (entry.envVar ? `env:${entry.envVar}` : undefined));
+            }
+            else {
+                this.secrets.set(name, { disk: current, loaded: current, external: false });
+            }
+        }
+        fs.writeFileSync(this.configPath, stringifyYaml(output), {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        // writeFileSync's `mode` only applies when creating the file, so an
+        // already-existing config.yaml keeps its prior permissions unless
+        // explicitly tightened here.
+        if (existed)
+            fs.chmodSync(this.configPath, 0o600);
+    }
+    loadFromDisk() {
+        const fromEnv = this.loadFromEnv();
+        if (!fs.existsSync(this.configPath)) {
+            const config = Object.keys(fromEnv).length > 0
+                ? ConfigSchema.parse(deepMerge(defaultConfig(), fromEnv))
+                : defaultConfig();
+            this.recordSecrets(new Map(), fromEnv, config);
+            return config;
+        }
+        const raw = fs.readFileSync(this.configPath, "utf8");
+        const parsed = (parseYaml(raw) ?? {});
+        const disk = new Map(SECRET_PATHS.map((secretPath) => [secretPathName(secretPath), getPath(parsed, secretPath)]));
+        const resolved = structuredClone(parsed);
+        for (const secretPath of SECRET_PATHS) {
+            const value = getPath(resolved, secretPath);
+            const wanted = !this.resolveFields || this.resolveFields.includes(secretPathName(secretPath));
+            // An env override wins anyway; do not fail on a ref it replaces.
+            if (isSecretRef(value) && wanted && getPath(fromEnv, secretPath) === undefined) {
+                setPath(resolved, secretPath, resolveSecretRef(value, this.secretOptions));
+            }
+        }
+        const config = ConfigSchema.parse(deepMerge(resolved, fromEnv));
+        this.recordSecrets(disk, fromEnv, config);
+        return config;
+    }
+    recordSecrets(disk, fromEnv, config) {
+        this.secrets = new Map(SECRET_PATHS.map((secretPath) => {
+            const name = secretPathName(secretPath);
+            const onDisk = disk.get(name);
+            const fromEnvValue = getPath(fromEnv, secretPath) !== undefined;
+            return [name, {
+                    disk: onDisk,
+                    envVar: fromEnvValue ? SECRET_ENV_VARS[name] : undefined,
+                    loaded: getPath(config, secretPath),
+                    external: isSecretRef(onDisk) || fromEnvValue,
+                }];
+        }));
+    }
+    loadFromEnv() {
+        const result = {};
+        if (process.env.FEISHU_APP_ID || process.env.FEISHU_APP_SECRET) {
+            result.feishu = {
+                domain: process.env.FEISHU_DOMAIN ?? "https://open.feishu.cn",
+                appId: process.env.FEISHU_APP_ID,
+                appSecret: process.env.FEISHU_APP_SECRET,
+            };
+        }
+        if (process.env.RUNNER_URL || process.env.RUNNER_TOKEN) {
+            result.runner = {
+                url: process.env.RUNNER_URL ?? "http://127.0.0.1:19789",
+                token: process.env.RUNNER_TOKEN,
+            };
+        }
+        if (process.env.TELEGRAM_BOT_TOKEN) {
+            result.telegram = {
+                botToken: process.env.TELEGRAM_BOT_TOKEN,
+            };
+        }
+        if (process.env.DEFAULT_BACKEND) {
+            result.defaultBackend = process.env.DEFAULT_BACKEND;
+        }
+        return result;
+    }
+}
+function deepMerge(base, override) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+        if (value &&
+            typeof value === "object" &&
+            !Array.isArray(value) &&
+            typeof out[key] === "object" &&
+            out[key] !== null &&
+            !Array.isArray(out[key])) {
+            // Skip undefined: RUNNER_URL alone must not blank a runner.token from disk.
+            const defined = Object.fromEntries(Object.entries(value).filter(([, v]) => v !== undefined));
+            out[key] = { ...out[key], ...defined };
+        }
+        else if (value !== undefined) {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=config-store.js.map

package/node_modules/@codebridge/core/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export * from "./session-event-wire.js";
+export * from "./workspace-key.js";
+export * from "./config-schema.js";
+export * from "./config-store.js";
+export * from "./secret-refs.js";
+export * from "./secret-migration.js";
+export * from "./json-file-store.js";
+export * from "./mentions.js";
+export type { StdioMcpServerConfig } from "./mcp-types.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/core/dist/index.js

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./session-event-wire.js";
+export * from "./workspace-key.js";
+export * from "./config-schema.js";
+export * from "./config-store.js";
+export * from "./secret-refs.js";
+export * from "./secret-migration.js";
+export * from "./json-file-store.js";
+export * from "./mentions.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/core/dist/json-file-store.d.ts

@@ -0,0 +1,16 @@
+export declare class JsonFileStore<T> {
+    private readonly filePath;
+    constructor(filePath: string);
+    read(): T;
+    write(data: T): void;
+    update(mutator: (current: T) => T): T;
+    protected defaultValue(): T;
+}
+export declare class JsonMapStore<V> extends JsonFileStore<Record<string, V>> {
+    protected defaultValue(): Record<string, V>;
+}
+export declare class JsonArrayStore<V> extends JsonFileStore<V[]> {
+    protected defaultValue(): V[];
+}
+export declare function appendJsonl(filePath: string, record: unknown): void;
+//# sourceMappingURL=json-file-store.d.ts.map

package/node_modules/@codebridge/core/dist/json-file-store.js

@@ -0,0 +1,46 @@
+import fs from "node:fs";
+import path from "node:path";
+export class JsonFileStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    read() {
+        if (!fs.existsSync(this.filePath)) {
+            return this.defaultValue();
+        }
+        const raw = fs.readFileSync(this.filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    write(data) {
+        const dir = path.dirname(this.filePath);
+        fs.mkdirSync(dir, { recursive: true });
+        const tmp = `${this.filePath}.tmp`;
+        fs.writeFileSync(tmp, JSON.stringify(data, null, 2), "utf8");
+        fs.renameSync(tmp, this.filePath);
+    }
+    update(mutator) {
+        const next = mutator(this.read());
+        this.write(next);
+        return next;
+    }
+    defaultValue() {
+        throw new Error("JsonFileStore requires override of defaultValue()");
+    }
+}
+export class JsonMapStore extends JsonFileStore {
+    defaultValue() {
+        return {};
+    }
+}
+export class JsonArrayStore extends JsonFileStore {
+    defaultValue() {
+        return [];
+    }
+}
+export function appendJsonl(filePath, record) {
+    const dir = path.dirname(filePath);
+    fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(filePath, `${JSON.stringify(record)}\n`, "utf8");
+}
+//# sourceMappingURL=json-file-store.js.map

package/node_modules/@codebridge/core/dist/mcp-types.d.ts

@@ -0,0 +1,7 @@
+export interface StdioMcpServerConfig {
+    name: string;
+    command: string;
+    args: string[];
+    env: Record<string, string>;
+}
+//# sourceMappingURL=mcp-types.d.ts.map

package/node_modules/@codebridge/core/dist/mcp-types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp-types.js.map

package/node_modules/@codebridge/core/dist/mentions.d.ts

@@ -0,0 +1,36 @@
+export type MentionTargetKind = "user" | "bot";
+export interface MentionScope {
+    chatId: string;
+    topicId?: string;
+}
+export interface MentionTarget {
+    channel: string;
+    kind: MentionTargetKind;
+    id: string;
+    name?: string;
+    username?: string;
+}
+export interface RegisteredMentionTarget extends MentionTarget {
+    ref: string;
+}
+export declare class MentionRegistry {
+    private readonly targetByKey;
+    private readonly targetByRef;
+    private readonly refsByScope;
+    private nextUserRef;
+    private nextBotRef;
+    private readonly store?;
+    constructor(filePath?: string);
+    register(scope: MentionScope, target: MentionTarget): RegisteredMentionTarget;
+    /** Drop stored names that are really labels (e.g. a role written by an older version). Returns how many were cleared. */
+    forgetNames(names: readonly string[]): number;
+    private save;
+    resolve(scope: MentionScope, ref: string): RegisteredMentionTarget | undefined;
+    list(scope: MentionScope): RegisteredMentionTarget[];
+}
+/**
+ * `roles` labels a target for this prompt only (e.g. an alert approver).
+ * Roles are never stored as the target's name: the registry is shared across chats.
+ */
+export declare function formatMentionGuidance(targets: RegisteredMentionTarget[], requesterRef?: string, roles?: Record<string, string>): string;
+//# sourceMappingURL=mentions.d.ts.map