@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/backends/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@codebridge/backends",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@agentclientprotocol/sdk": "1.3.0",
+    "@codebridge/core": "0.1.0",
+    "@codebridge/session-catalog": "0.1.0",
+    "@earendil-works/pi-ai": "0.87.1",
+    "@earendil-works/pi-coding-agent": "0.87.1",
+    "zod": "3.25.76"
+  }
+}

package/node_modules/@codebridge/bridge/dist/alert-notification-rules.d.ts

@@ -0,0 +1,14 @@
+import type { FeishuAlertMessage } from "@codebridge/channel-feishu";
+export interface AlertNotificationRule {
+    id: string;
+    kind: "notification";
+    verified: true;
+    senderAppIds: string[];
+    title: string;
+    bodyIncludes: string[];
+    summary: string;
+    evidence: string;
+}
+/** Only a unique, explicitly verified notification rule may merge different business entities. */
+export declare function matchAlertNotificationRule(runbookPath: string | undefined, message: FeishuAlertMessage): AlertNotificationRule | undefined;
+//# sourceMappingURL=alert-notification-rules.d.ts.map

package/node_modules/@codebridge/bridge/dist/alert-notification-rules.js

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import path from "node:path";
+/** Only a unique, explicitly verified notification rule may merge different business entities. */
+export function matchAlertNotificationRule(runbookPath, message) {
+    if (!runbookPath)
+        return undefined;
+    const file = path.join(path.dirname(runbookPath), "references", "notification-rules.json");
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    if (Buffer.byteLength(raw) > 64_000)
+        throw new Error("Notification rules too large");
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.rules))
+        throw new Error("Invalid notification rules");
+    const matches = parsed.rules.filter((value) => {
+        if (!value || typeof value !== "object")
+            return false;
+        const rule = value;
+        return rule.kind === "notification" && rule.verified === true
+            && typeof rule.id === "string" && Boolean(rule.id.trim())
+            && typeof rule.evidence === "string" && Boolean(rule.evidence.trim())
+            && typeof rule.summary === "string" && Boolean(rule.summary.trim()) && rule.summary.length <= 2000
+            && Array.isArray(rule.senderAppIds) && rule.senderAppIds.includes(message.senderId)
+            && typeof rule.title === "string" && Boolean(rule.title.trim()) && message.content.split("\n")[0]?.trim() === rule.title
+            && Array.isArray(rule.bodyIncludes) && rule.bodyIncludes.length > 0
+            && rule.bodyIncludes.every((part) => typeof part === "string" && Boolean(part.trim()) && message.content.split("\n").some((line) => line.trim() === part.trim()));
+    });
+    return matches.length === 1 ? matches[0] : undefined;
+}
+//# sourceMappingURL=alert-notification-rules.js.map

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

@@ -0,0 +1,4 @@
+import type { AppConfig } from "@codebridge/core";
+export declare function hasFeishuCredentials(config: AppConfig): boolean;
+export declare function hasTelegramCredentials(config: AppConfig): boolean;
+//# sourceMappingURL=channel-config.d.ts.map

package/node_modules/@codebridge/bridge/dist/channel-config.js

@@ -0,0 +1,9 @@
+export function hasFeishuCredentials(config) {
+    return (config.feishu?.appId !== undefined &&
+        config.feishu.appId !== "cli_placeholder" &&
+        config.feishu.appSecret !== "secret_placeholder");
+}
+export function hasTelegramCredentials(config) {
+    return Boolean(config.telegram?.botToken);
+}
+//# sourceMappingURL=channel-config.js.map

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

@@ -0,0 +1,5 @@
+import type { ChannelSessionIngress } from "@codebridge/core";
+import { Hono } from "hono";
+export declare function createChannelIngressApi(sessionApp: Hono): Hono;
+export declare function createChannelSessionIngress(app: Hono, token: string): ChannelSessionIngress;
+//# sourceMappingURL=channel-ingress.d.ts.map

package/node_modules/@codebridge/bridge/dist/channel-ingress.js

@@ -0,0 +1,403 @@
+import { parseSessionEventWire } from "@codebridge/core/session-event-wire";
+import { Hono } from "hono";
+function toChannelSessionEvent(input) {
+    const event = parseSessionEventWire(input);
+    return {
+        type: event.type,
+        sequence: event.sequence,
+        runId: event.run_id,
+        executionKind: event.execution_kind,
+        occurredAt: event.occurred_at,
+        target: event.target,
+        resultRef: event.result_ref,
+        payload: event.payload,
+    };
+}
+function requireSessionEventContentType(response, expected) {
+    const actual = response.headers.get("content-type")?.toLowerCase() ?? "";
+    if (!actual.includes(expected)) {
+        throw new Error("session_event_transport_mismatch");
+    }
+}
+export function createChannelIngressApi(sessionApp) {
+    const app = new Hono();
+    app.route("/", sessionApp);
+    return app;
+}
+export function createChannelSessionIngress(app, token) {
+    const auth = { authorization: `Bearer ${token}` };
+    const readRuntimeVersion = async (sessionId) => {
+        const response = await app.request(`/v1/sessions/${encodeURIComponent(sessionId)}`, { headers: auth });
+        if (!response.ok) {
+            throw new Error(`read runtime failed (${response.status}): ${await response.text()}`);
+        }
+        const body = await response.json();
+        if (typeof body.runtime?.version !== "number") {
+            throw new Error("runtime version missing in snapshot");
+        }
+        return body.runtime.version;
+    };
+    const submit = async (message) => {
+        if ((message.replyToMessageId === undefined)
+            !== (message.showThinking === undefined)) {
+            throw new Error("channel_delivery_incomplete");
+        }
+        const accepted = await app.request(`/v1/channels/${encodeURIComponent(message.channel)}/conversations/${encodeURIComponent(message.conversationId)}/messages`, {
+            method: "POST",
+            headers: {
+                ...auth,
+                "content-type": "application/json",
+                ...(message.idempotencyKey
+                    ? { "idempotency-key": message.idempotencyKey }
+                    : {}),
+            },
+            body: JSON.stringify({
+                message: message.message,
+                agent_id: message.agentId,
+                cwd: message.cwd,
+                model: message.model,
+                ...(message.inputs !== undefined ? { inputs: message.inputs } : {}),
+                ...(message.actorRef !== undefined ? { actor_ref: message.actorRef } : {}),
+                generation: message.generation,
+                reply_to_message_id: message.replyToMessageId,
+                show_thinking: message.showThinking,
+                attachments: message.attachments?.map((attachment) => ({
+                    name: attachment.name,
+                    mime_type: attachment.mimeType,
+                    data_base64: attachment.dataBase64,
+                })),
+            }),
+        });
+        if (!accepted.ok) {
+            throw new Error(`Channel submit failed (${accepted.status}): ${await accepted.text()}`);
+        }
+        const result = await accepted.json();
+        return {
+            sessionId: result.session_id,
+            turnId: result.turn_id,
+            runId: result.run_id,
+            acceptance: result.acceptance,
+            queueState: result.queue_state,
+            eventSequence: result.event_sequence,
+        };
+    };
+    const listRuntimeApprovals = async (runId) => {
+        const response = await app.request(`/v1/runs/${encodeURIComponent(runId)}/approvals`, { headers: auth });
+        if (!response.ok) {
+            throw new Error(`list Runtime approvals failed (${response.status}): ${await response.text()}`);
+        }
+        const body = await response.json();
+        return body.approvals.map(toChannelRuntimeApproval);
+    };
+    const resolveRuntimeApproval = async (runId, approvalId, decision) => {
+        const response = await app.request(`/v1/runs/${encodeURIComponent(runId)}/${decision}`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ approval_id: approvalId }),
+        });
+        if (!response.ok) {
+            throw new Error(`resolve Runtime approval failed (${response.status}): ${await response.text()}`);
+        }
+        const body = await response.json();
+        return {
+            id: body.approval_id,
+            runId,
+            stepId: null,
+            capabilityId: null,
+            status: body.status,
+            environment: null,
+            targetResource: null,
+            expiresAt: null,
+        };
+    };
+    const events = async function* (sessionId, opts) {
+        const response = await app.request(`/v1/sessions/${encodeURIComponent(sessionId)}/events?live=true&after_sequence=${opts.afterSequence}`, { headers: auth, signal: opts.signal });
+        if (!response.ok || !response.body) {
+            throw new Error(`Channel event stream failed (${response.status})`);
+        }
+        requireSessionEventContentType(response, "text/event-stream");
+        for await (const event of readSessionEvents(response.body, opts.signal)) {
+            yield toChannelSessionEvent(event);
+        }
+    };
+    const replayEvents = async (sessionId, opts) => {
+        const replayed = [];
+        let cursor = opts.afterSequence;
+        while (true) {
+            const response = await app.request(`/v1/sessions/${encodeURIComponent(sessionId)}/events?after_sequence=${cursor}&limit=500`, { headers: auth });
+            if (!response.ok) {
+                throw new Error(`Channel event replay failed (${response.status})`);
+            }
+            requireSessionEventContentType(response, "application/json");
+            const page = await response.json();
+            if (!Array.isArray(page.events)
+                || !Number.isInteger(page.next_sequence)
+                || typeof page.has_more !== "boolean") {
+                throw new Error("session_event_schema_mismatch");
+            }
+            replayed.push(...page.events.map(toChannelSessionEvent));
+            if (!page.has_more)
+                return replayed;
+            const next = page.next_sequence;
+            if (next <= cursor)
+                throw new Error("session_event_schema_mismatch");
+            cursor = next;
+        }
+    };
+    const listDeliveries = async (channel, surfaceMessageId) => {
+        const response = await app.request(`/v1/deliveries?channel=${encodeURIComponent(channel)}`
+            + (surfaceMessageId !== undefined ? `&surface_message_id=${encodeURIComponent(surfaceMessageId)}` : ""), { headers: auth });
+        if (!response.ok) {
+            throw new Error(`list deliveries failed (${response.status})`);
+        }
+        const body = await response.json();
+        return body.deliveries;
+    };
+    const claimDelivery = async (turnId, owner) => {
+        const response = await app.request(`/v1/deliveries/${encodeURIComponent(turnId)}/claim`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ owner }),
+        });
+        if (!response.ok) {
+            throw new Error(`claim delivery failed (${response.status}): ${await response.text()}`);
+        }
+        return (await response.json()).claimed === true;
+    };
+    const ackDelivery = async (turnId, owner, surfaceMessageId, surfaceCardId) => {
+        const response = await app.request(`/v1/deliveries/${encodeURIComponent(turnId)}/ack`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({
+                owner,
+                surface_message_id: surfaceMessageId,
+                ...(surfaceCardId ? { surface_card_id: surfaceCardId } : {}),
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`ack delivery failed (${response.status}): ${await response.text()}`);
+        }
+        return (await response.json()).acked === true;
+    };
+    const completeDelivery = async (turnId, owner) => {
+        const response = await app.request(`/v1/deliveries/${encodeURIComponent(turnId)}/complete`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ owner }),
+        });
+        if (!response.ok) {
+            throw new Error(`complete delivery failed (${response.status}): ${await response.text()}`);
+        }
+        return (await response.json()).completed === true;
+    };
+    const getSlotCommandContext = async (slot) => {
+        const response = await app.request("/v1/channels/command-context", {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({
+                slot: {
+                    channel: slot.channel,
+                    conversation_id: slot.conversationId,
+                    agent_id: slot.agentId,
+                    workspace_key: slot.workspaceKey,
+                    generation: slot.generation,
+                },
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(`command context failed (${response.status}): ${await response.text()}`);
+        }
+        const body = await response.json();
+        return {
+            sessionId: body.session_id,
+            activeRunId: body.active_run_id,
+            providerSessionId: body.provider_session_id ?? null,
+            lastActivityAt: body.last_activity_at ?? null,
+            contextUsed: body.context_used ?? null,
+            contextSize: body.context_size ?? null,
+            contextFirstUsed: body.context_first_used ?? null,
+            queuedTurns: body.queued_turns ?? 0,
+        };
+    };
+    const resolvePermission = async (runId, approve) => {
+        const response = await app.request(`/v1/runs/${encodeURIComponent(runId)}/permission`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ approve }),
+        });
+        if (!response.ok) {
+            throw new Error(`resolve permission failed (${response.status}): ${await response.text()}`);
+        }
+        return (await response.json()).resolved === true;
+    };
+    const cancelRun = async (sessionId, runId) => {
+        const version = await readRuntimeVersion(sessionId);
+        const response = await app.request(`/v1/runs/${encodeURIComponent(runId)}/cancel`, {
+            method: "POST",
+            headers: {
+                ...auth,
+                "content-type": "application/json",
+                "idempotency-key": `cancel:${runId}`,
+                "if-match": String(version),
+            },
+            body: "{}",
+        });
+        if (!response.ok) {
+            throw new Error(`cancel run failed (${response.status}): ${await response.text()}`);
+        }
+        return (await response.json()).disposition !== undefined;
+    };
+    const steerRun = async (runId, prompt) => {
+        const response = await app.request(`/v1/runs/${encodeURIComponent(runId)}/steer`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({ prompt }),
+        });
+        if (!response.ok) {
+            let message = `steer run failed (${response.status})`;
+            try {
+                const body = await response.json();
+                if (body.error)
+                    message = body.error;
+            }
+            catch {
+                // 非 JSON 错误体，保留默认消息
+            }
+            throw new Error(message);
+        }
+        return response.json();
+    };
+    const resumeQueue = async (sessionId, commandId) => {
+        const version = await readRuntimeVersion(sessionId);
+        const response = await app.request(`/v1/sessions/${encodeURIComponent(sessionId)}/queue/resume`, {
+            method: "POST",
+            headers: {
+                ...auth,
+                "content-type": "application/json",
+                "idempotency-key": `resume:${commandId}`,
+                "if-match": String(version),
+            },
+            body: "{}",
+        });
+        if (!response.ok) {
+            throw new Error(`resume queue failed (${response.status}): ${await response.text()}`);
+        }
+        const body = await response.json();
+        return { queueState: body.runtime?.queue_state ?? "ready" };
+    };
+    const resetSlot = async (slot) => {
+        const response = await app.request(`/v1/channels/${encodeURIComponent(slot.channel)}/conversations/${encodeURIComponent(slot.conversationId)}/reset`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({
+                agent_id: slot.agentId,
+                workspace_key: slot.workspaceKey,
+                generation: slot.generation,
+            }),
+        });
+        if (!response.ok)
+            return false;
+        return (await response.json()).reset === true;
+    };
+    const resumeProviderSession = async (slot, providerSessionId) => {
+        const response = await app.request(`/v1/channels/${encodeURIComponent(slot.channel)}/conversations/${encodeURIComponent(slot.conversationId)}/resume`, {
+            method: "POST",
+            headers: { ...auth, "content-type": "application/json" },
+            body: JSON.stringify({
+                agent_id: slot.agentId,
+                workspace_key: slot.workspaceKey,
+                generation: slot.generation,
+                provider_session_id: providerSessionId,
+            }),
+        });
+        if (!response.ok) {
+            let message = `resume provider session failed (${response.status})`;
+            let detail;
+            try {
+                const body = await response.json();
+                if (body.error)
+                    message = body.error;
+                detail = body.detail;
+            }
+            catch {
+                // 非 JSON 错误体，保留默认消息
+            }
+            // 只 throw 错误码（detail 挂到 Error.detail），便于 bridge 按码精确匹配。
+            const error = new Error(message);
+            if (detail)
+                error.detail = detail;
+            throw error;
+        }
+        const body = await response.json();
+        return { sessionId: body.session_id };
+    };
+    return {
+        submit,
+        listRuntimeApprovals,
+        resolveRuntimeApproval,
+        events,
+        replayEvents,
+        listDeliveries,
+        claimDelivery,
+        ackDelivery,
+        completeDelivery,
+        getSlotCommandContext,
+        resumeProviderSession,
+        cancelRun,
+        steerRun,
+        resolvePermission,
+        resumeQueue,
+        resetSlot,
+    };
+}
+function toChannelRuntimeApproval(input) {
+    return {
+        id: input.id,
+        runId: input.run_id,
+        stepId: input.step_id ?? null,
+        capabilityId: input.capability_id ?? null,
+        status: input.status,
+        environment: input.environment ?? null,
+        targetResource: input.target_resource ?? null,
+        expiresAt: input.expires_at ?? null,
+    };
+}
+async function* readSessionEvents(body, signal) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    const abort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    if (signal?.aborted)
+        abort();
+    else
+        signal?.addEventListener("abort", abort, { once: true });
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            buffer += decoder.decode(value, { stream: !done });
+            let boundary = buffer.indexOf("\n\n");
+            while (boundary >= 0) {
+                const frame = buffer.slice(0, boundary);
+                buffer = buffer.slice(boundary + 2);
+                const data = frame
+                    .split("\n")
+                    .filter((line) => line.startsWith("data:"))
+                    .map((line) => line.slice("data:".length).trimStart())
+                    .join("\n");
+                if (data)
+                    yield JSON.parse(data);
+                boundary = buffer.indexOf("\n\n");
+            }
+            if (done)
+                return;
+        }
+    }
+    finally {
+        signal?.removeEventListener("abort", abort);
+        await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+//# sourceMappingURL=channel-ingress.js.map

package/node_modules/@codebridge/bridge/dist/cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=cli.d.ts.map