@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/bridge/dist/session-runtime-types.d.ts

@@ -0,0 +1,85 @@
+import type { AgentSession } from "@codebridge/session-catalog";
+import type { SessionEventWire } from "@codebridge/core/session-event-wire";
+import type { DomainEvent, Run, SessionTimelineTurn, SessionTurn } from "@codebridge/work-items";
+export declare function toApiSessionEvent(event: DomainEvent): SessionEventWire;
+export declare function toApiSession(session: AgentSession): {
+    schema_version: 1;
+    session_id: string;
+    agent_id: string;
+    provider_session_id: string | null;
+    task_record_id: string | null;
+    model: string | null;
+    effort: string | null;
+    config_overrides: import("@codebridge/session-catalog").SessionConfigOverrides;
+    permission_mode: string | null;
+    folder_id: string | null;
+    cwd: string | null;
+    additional_directories: string[];
+    title: string | null;
+    status: import("@codebridge/session-catalog").SessionStatus;
+    pinned_at: string | null;
+    archived_at: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function toApiRun(run: Run, sessionId: string): {
+    schema_version: 1;
+    run_id: string;
+    session_id: string;
+    work_item_id: string;
+    turn_id: string | null;
+    execution_kind: import("@codebridge/work-items").ExecutionKind;
+    agent_id: string | null;
+    plan_id: string | null;
+    workflow_revision: string | null;
+    mode: import("@codebridge/work-items").WorkItemMode;
+    status: import("@codebridge/work-items").RunStatus;
+    terminal_reason: string | null;
+    created_at: string;
+    updated_at: string;
+};
+export declare function toApiSessionTurn(turn: SessionTurn): {
+    turn_id: string;
+    queue_position: number;
+    status: import("@codebridge/work-items").SessionTurnStatus;
+    version: number;
+    message: {
+        text: string;
+        attachment_ids: string[];
+    };
+    created_at: string;
+};
+export declare function toApiTimeline(input: {
+    turns: SessionTimelineTurn[];
+    previousCursor: number | null;
+    truncatedBlockIds: string[];
+}): {
+    turns: {
+        timeline_index: number;
+        turn_id: string;
+        run_id: string;
+        status: import("@codebridge/work-items").TimelineTurnStatus;
+        blocks: {
+            block_id: string;
+            block_index: number;
+            kind: string;
+            status: string;
+            metadata: Record<string, unknown>;
+            segments: {
+                segment_id: string;
+                segment_index: number;
+                content: string;
+                byte_length: number;
+                sealed: boolean;
+            }[];
+            next_segment_cursor: number | null;
+        }[];
+    }[];
+    previous_cursor: number | null;
+    truncated_block_ids: string[];
+};
+export type ApiSession = ReturnType<typeof toApiSession>;
+export type ApiRun = ReturnType<typeof toApiRun>;
+export type ApiSessionTurn = ReturnType<typeof toApiSessionTurn>;
+export type ApiTimeline = ReturnType<typeof toApiTimeline>;
+//# sourceMappingURL=session-runtime-types.d.ts.map

package/node_modules/@codebridge/bridge/dist/session-runtime-types.js

@@ -0,0 +1,98 @@
+export function toApiSessionEvent(event) {
+    return {
+        schema_version: event.schemaVersion,
+        event_id: event.eventId,
+        sequence: event.sequence,
+        work_item_id: event.workItemId,
+        run_id: event.runId,
+        execution_kind: event.executionKind,
+        type: event.type,
+        occurred_at: event.occurredAt,
+        actor: event.actor,
+        target: event.target,
+        input_hash: event.inputHash,
+        result_ref: event.resultRef,
+        payload: event.payload,
+    };
+}
+export function toApiSession(session) {
+    return {
+        schema_version: session.schemaVersion,
+        session_id: session.id,
+        agent_id: session.agentId,
+        provider_session_id: session.providerSessionId,
+        task_record_id: session.taskRecordId,
+        model: session.model,
+        effort: session.effort,
+        config_overrides: session.configOverrides,
+        permission_mode: session.permissionMode,
+        folder_id: session.folderId,
+        cwd: session.cwd,
+        additional_directories: session.additionalDirectories,
+        title: session.title,
+        status: session.status,
+        pinned_at: session.pinnedAt,
+        archived_at: session.archivedAt,
+        created_at: session.createdAt,
+        updated_at: session.updatedAt,
+    };
+}
+export function toApiRun(run, sessionId) {
+    return {
+        schema_version: run.schemaVersion,
+        run_id: run.id,
+        session_id: sessionId,
+        work_item_id: run.workItemId,
+        turn_id: run.turnId,
+        execution_kind: run.executionKind,
+        agent_id: run.agentId,
+        plan_id: run.planId,
+        workflow_revision: run.workflowRevision,
+        mode: run.mode,
+        status: run.status,
+        terminal_reason: run.terminalReason,
+        created_at: run.createdAt,
+        updated_at: run.updatedAt,
+    };
+}
+export function toApiSessionTurn(turn) {
+    return {
+        turn_id: turn.turnId,
+        queue_position: turn.queuePosition,
+        status: turn.status,
+        version: turn.version,
+        message: {
+            text: turn.message.text,
+            attachment_ids: turn.message.attachmentIds,
+        },
+        created_at: turn.createdAt,
+    };
+}
+export function toApiTimeline(input) {
+    return {
+        turns: input.turns.map((turn) => ({
+            timeline_index: turn.timelineIndex,
+            turn_id: turn.turnId,
+            run_id: turn.runId,
+            status: turn.status,
+            blocks: turn.blocks.map((block) => ({
+                block_id: block.blockId,
+                block_index: block.blockIndex,
+                kind: block.kind,
+                status: block.status,
+                metadata: block.metadata,
+                segments: block.segments.map((segment) => ({
+                    segment_id: segment.segmentId,
+                    segment_index: segment.segmentIndex,
+                    content: segment.content,
+                    byte_length: segment.byteLength,
+                    sealed: segment.sealed,
+                })),
+                next_segment_cursor: block.nextSegmentCursor,
+            })),
+        })),
+        previous_cursor: input.previousCursor,
+        truncated_block_ids: input.truncatedBlockIds,
+    };
+}
+//# sourceMappingURL=session-runtime-types.js.map

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

@@ -0,0 +1,28 @@
+import { Hono } from "hono";
+import type { SkillAgentId, SkillCatalogSnapshot, SkillMutationPlan, SkillMutationResult } from "@codebridge/runner-client";
+export interface SkillRunner {
+    listSkills(): Promise<SkillCatalogSnapshot>;
+    addSkillSource(sourcePath: string): Promise<SkillCatalogSnapshot>;
+    previewSkillAdopt(skillId: string, actorId: string): Promise<SkillMutationPlan>;
+    previewSkillAssignment(input: {
+        skill_id: string;
+        agent_id: SkillAgentId;
+        enabled: boolean;
+        actor_id: string;
+    }): Promise<SkillMutationPlan>;
+    previewSkillGlobalState(input: {
+        skill_id: string;
+        enabled: boolean;
+        actor_id: string;
+    }): Promise<SkillMutationPlan>;
+    previewSkillUnmanage(skillId: string, actorId: string): Promise<SkillMutationPlan>;
+    applySkillPlan(kind: "adopt" | "global-state" | "assignment" | "unmanage", planId: string, actorId: string): Promise<SkillMutationResult>;
+    pickDirectory(): Promise<{
+        ok: boolean;
+        path?: string;
+        cancelled?: boolean;
+        error?: string;
+    }>;
+}
+export declare function createSkillApp(runner: SkillRunner, token: string): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=skill-api.d.ts.map

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

@@ -0,0 +1,129 @@
+import { Hono } from "hono";
+const SKILL_AGENT_IDS = new Set(["codex", "claude", "cursor", "opencode", "pi"]);
+const LOCAL_SKILL_ACTOR = "local:web";
+export function createSkillApp(runner, token) {
+    const app = new Hono();
+    app.use("/v1/*", async (c, next) => {
+        if (c.req.header("authorization") !== `Bearer ${token}`) {
+            return c.json({ error: "unauthorized" }, 401);
+        }
+        await next();
+    });
+    app.get("/v1/skills", async (c) => {
+        try {
+            return c.json(await runner.listSkills());
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/sources", async (c) => {
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.path !== "string" || !body.path.trim()) {
+            return c.json({ error: "invalid_skill_source", message: "path is required" }, 400);
+        }
+        try {
+            return c.json(await runner.addSkillSource(body.path.trim()));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/sources/pick", async (c) => {
+        try {
+            const picked = await runner.pickDirectory();
+            if (picked.cancelled)
+                return c.json({ cancelled: true });
+            if (!picked.ok || !picked.path) {
+                return c.json({
+                    error: "directory_picker_failed",
+                    message: picked.error ?? "目录选择失败",
+                }, 503);
+            }
+            return c.json(await runner.addSkillSource(picked.path));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/:skillId/adopt/preview", async (c) => {
+        try {
+            return c.json(await runner.previewSkillAdopt(c.req.param("skillId"), LOCAL_SKILL_ACTOR));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/:skillId/global-state/preview", async (c) => {
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.enabled !== "boolean") {
+            return c.json({ error: "invalid_skill_global_state" }, 400);
+        }
+        try {
+            return c.json(await runner.previewSkillGlobalState({
+                skill_id: c.req.param("skillId"),
+                enabled: body.enabled,
+                actor_id: LOCAL_SKILL_ACTOR,
+            }));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/assignments/preview", async (c) => {
+        const input = await readAssignment(c);
+        if (!input)
+            return c.json({ error: "invalid_skill_assignment" }, 400);
+        try {
+            return c.json(await runner.previewSkillAssignment({ ...input, actor_id: LOCAL_SKILL_ACTOR }));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    app.post("/v1/skills/:skillId/unmanage/preview", async (c) => {
+        try {
+            return c.json(await runner.previewSkillUnmanage(c.req.param("skillId"), LOCAL_SKILL_ACTOR));
+        }
+        catch (error) {
+            return runnerErrorResponse(c, error);
+        }
+    });
+    for (const kind of ["adopt", "global-state", "assignment", "unmanage"]) {
+        app.post(`/v1/skills/${kind}-plans/:planId/apply`, async (c) => {
+            try {
+                return c.json(await runner.applySkillPlan(kind, c.req.param("planId"), LOCAL_SKILL_ACTOR));
+            }
+            catch (error) {
+                return runnerErrorResponse(c, error);
+            }
+        });
+    }
+    return app;
+}
+async function readAssignment(c) {
+    const body = await c.req.json().catch(() => null);
+    if (!body
+        || typeof body.skill_id !== "string"
+        || !body.skill_id.trim()
+        || typeof body.agent_id !== "string"
+        || !SKILL_AGENT_IDS.has(body.agent_id)
+        || typeof body.enabled !== "boolean") {
+        return null;
+    }
+    return {
+        skill_id: body.skill_id.trim(),
+        agent_id: body.agent_id,
+        enabled: body.enabled,
+    };
+}
+function runnerErrorResponse(c, error) {
+    const value = error;
+    const status = value?.status === 400 || value?.status === 404 || value?.status === 409 || value?.status === 422
+        ? value.status
+        : 503;
+    const code = typeof value?.code === "string" ? value.code : "runner_unavailable";
+    const message = typeof value?.message === "string" ? value.message : String(error);
+    return c.json({ error: code, message }, status);
+}
+//# sourceMappingURL=skill-api.js.map

package/node_modules/@codebridge/bridge/dist/startup-surfaces.d.ts

@@ -0,0 +1,15 @@
+import type { AppConfig } from "@codebridge/core";
+export interface StartupSurfaces {
+    web: boolean;
+    feishu: boolean;
+    telegram: boolean;
+}
+export interface StartupOverrides {
+    web?: boolean;
+}
+/**
+ * Entrances are independent. The Core API may run with no channel and Web is
+ * opt-in so a headless install does not open a browser surface accidentally.
+ */
+export declare function resolveStartupSurfaces(config: AppConfig, overrides?: StartupOverrides): StartupSurfaces;
+//# sourceMappingURL=startup-surfaces.d.ts.map

package/node_modules/@codebridge/bridge/dist/startup-surfaces.js

@@ -0,0 +1,13 @@
+import { hasFeishuCredentials, hasTelegramCredentials } from "./channel-config.js";
+/**
+ * Entrances are independent. The Core API may run with no channel and Web is
+ * opt-in so a headless install does not open a browser surface accidentally.
+ */
+export function resolveStartupSurfaces(config, overrides = {}) {
+    return {
+        web: overrides.web ?? config.web.enabled,
+        feishu: hasFeishuCredentials(config),
+        telegram: hasTelegramCredentials(config),
+    };
+}
+//# sourceMappingURL=startup-surfaces.js.map

package/node_modules/@codebridge/bridge/dist/web-frontend.d.ts

@@ -0,0 +1,8 @@
+import { Hono } from "hono";
+export interface WebFrontendOptions {
+    staticDirectory: string;
+    token?: string;
+}
+/** Serves the optional Vite build without adding a second backend contract. */
+export declare function createWebFrontendApp(options: WebFrontendOptions): Hono;
+//# sourceMappingURL=web-frontend.d.ts.map

package/node_modules/@codebridge/bridge/dist/web-frontend.js

@@ -0,0 +1,76 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { Hono } from "hono";
+const MIME_TYPES = {
+    ".css": "text/css; charset=UTF-8",
+    ".gif": "image/gif",
+    ".html": "text/html; charset=UTF-8",
+    ".ico": "image/x-icon",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".js": "text/javascript; charset=UTF-8",
+    ".json": "application/json; charset=UTF-8",
+    ".map": "application/json; charset=UTF-8",
+    ".png": "image/png",
+    ".svg": "image/svg+xml",
+    ".webp": "image/webp",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+};
+/** Serves the optional Vite build without adding a second backend contract. */
+export function createWebFrontendApp(options) {
+    const app = new Hono();
+    app.get("/config.json", (c) => {
+        return c.json({ token: options.token ?? "" }, 200, {
+            "cache-control": "no-store",
+        });
+    });
+    app.get("*", async (c) => {
+        const requestedPath = decodeURIComponent(new URL(c.req.url).pathname);
+        const pathname = requestedPath === "/workbench"
+            ? "/"
+            : requestedPath.startsWith("/workbench/")
+                ? requestedPath.slice("/workbench".length)
+                : requestedPath;
+        const relative = pathname === "/" ? "index.html" : pathname.replace(/^\/+/, "");
+        if (relative === "config.json" || relative.includes("..")) {
+            return c.notFound();
+        }
+        const direct = await readFile(options.staticDirectory, relative);
+        if (direct)
+            return directResponse(direct, relative);
+        // Client-side routes are rendered by the same React entry point.
+        if (!path.extname(relative)) {
+            const fallback = await readFile(options.staticDirectory, "index.html");
+            if (fallback)
+                return directResponse(fallback, "index.html");
+        }
+        return c.notFound();
+    });
+    return app;
+}
+async function readFile(root, relative) {
+    const target = path.resolve(root, relative);
+    const rootPath = path.resolve(root);
+    if (target !== rootPath && !target.startsWith(`${rootPath}${path.sep}`))
+        return undefined;
+    try {
+        const stat = await fs.stat(target);
+        if (!stat.isFile())
+            return undefined;
+        return await fs.readFile(target);
+    }
+    catch {
+        return undefined;
+    }
+}
+function directResponse(content, relative) {
+    const extension = path.extname(relative).toLowerCase();
+    return new Response(content, {
+        headers: {
+            "cache-control": relative === "index.html" ? "no-cache" : "public, max-age=31536000, immutable",
+            "content-type": MIME_TYPES[extension] ?? "application/octet-stream",
+        },
+    });
+}
+//# sourceMappingURL=web-frontend.js.map

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

@@ -0,0 +1,6 @@
+import type { ApprovalService } from "@codebridge/policy";
+import type { RunExecutor } from "@codebridge/run-executor";
+import { SqliteEventStore } from "@codebridge/work-items";
+import { Hono } from "hono";
+export declare function createWorkItemApp(store: SqliteEventStore, token: string, approvals?: ApprovalService, executor?: RunExecutor): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+//# sourceMappingURL=work-item-api.d.ts.map