@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/bridge/dist/session-history-import.d.ts

@@ -0,0 +1,24 @@
+import type { SessionCatalogStore } from "@codebridge/session-catalog";
+import type { RunnerClient } from "@codebridge/runner-client";
+import type { ProviderHistoryImportResult, SqliteEventStore } from "@codebridge/work-items";
+export declare class ProviderHistoryImporter {
+    private readonly dependencies;
+    constructor(dependencies: {
+        store: SqliteEventStore;
+        catalog: SessionCatalogStore;
+        runner: RunnerClient;
+        defaultCwd?: string;
+    });
+    preview(sessionId: string): Promise<{
+        providerSessionId: string;
+        importedPosition: number;
+        providerPosition: number;
+        importableEvents: number;
+        nextDigest: string;
+    }>;
+    import(sessionId: string, idempotencyKey: string): Promise<ProviderHistoryImportResult>;
+    private bindTaskRecord;
+    private requireBoundSession;
+    private load;
+}
+//# sourceMappingURL=session-history-import.d.ts.map

package/node_modules/@codebridge/bridge/dist/session-history-import.js

@@ -0,0 +1,82 @@
+import { createHash } from "node:crypto";
+function digest(events, end = events.length) {
+    return `sha256:${createHash("sha256")
+        .update(JSON.stringify(events.slice(0, end)))
+        .digest("hex")}`;
+}
+export class ProviderHistoryImporter {
+    dependencies;
+    constructor(dependencies) {
+        this.dependencies = dependencies;
+    }
+    async preview(sessionId) {
+        const session = this.requireBoundSession(sessionId);
+        const history = await this.load(session);
+        const prior = this.dependencies.store.getProviderHistoryImport(session.id, session.providerSessionId);
+        if (prior
+            && digest(history, prior.importedPosition)
+                !== prior.providerDigest) {
+            throw new Error("provider_history_prefix_changed");
+        }
+        return {
+            providerSessionId: session.providerSessionId,
+            importedPosition: prior?.importedPosition ?? 0,
+            providerPosition: history.length,
+            importableEvents: history.length - (prior?.importedPosition ?? 0),
+            nextDigest: digest(history),
+        };
+    }
+    async import(sessionId, idempotencyKey) {
+        const namespace = `session:history-import:${sessionId}`;
+        const cached = this.dependencies.store.getIdempotencyResponse(namespace, idempotencyKey);
+        if (cached) {
+            this.bindTaskRecord(sessionId);
+            return cached;
+        }
+        const session = this.requireBoundSession(sessionId);
+        const history = await this.load(session);
+        const prior = this.dependencies.store.getProviderHistoryImport(session.id, session.providerSessionId);
+        const priorPosition = prior?.importedPosition ?? 0;
+        const priorDigest = digest(history, priorPosition);
+        if (prior && priorDigest !== prior.providerDigest) {
+            throw new Error("provider_history_prefix_changed");
+        }
+        const result = this.dependencies.store.importProviderHistory({
+            sessionId,
+            providerSessionId: session.providerSessionId,
+            priorPosition,
+            priorDigest,
+            nextDigest: digest(history),
+            events: history.slice(priorPosition),
+            idempotencyKey,
+        });
+        this.bindTaskRecord(sessionId);
+        return result;
+    }
+    bindTaskRecord(sessionId) {
+        const workItem = this.dependencies.store.getWorkItemBySessionId(sessionId);
+        if (!workItem) {
+            throw new Error("provider_history_work_item_missing");
+        }
+        if (this.dependencies.catalog.getSession(sessionId)?.taskRecordId
+            === workItem.id) {
+            return;
+        }
+        this.dependencies.catalog.updateSession(sessionId, {
+            taskRecordId: workItem.id,
+        });
+    }
+    requireBoundSession(sessionId) {
+        const session = this.dependencies.catalog.getSession(sessionId);
+        if (!session)
+            throw new Error("session_not_found");
+        if (!session.providerSessionId) {
+            throw new Error("provider_session_not_bound");
+        }
+        return session;
+    }
+    load(session) {
+        return this.dependencies.runner.loadSessionHistory(session.agentId, session.cwd ?? this.dependencies.defaultCwd ?? process.cwd(), session.providerSessionId, session.additionalDirectories);
+    }
+}
+//# sourceMappingURL=session-history-import.js.map

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

@@ -0,0 +1,19 @@
+import type { CapabilityRegistry } from "@codebridge/policy";
+import type { RunExecutor } from "@codebridge/run-executor";
+import type { SessionCatalogStore } from "@codebridge/session-catalog";
+import { type SessionCoordinator } from "@codebridge/session-coordinator";
+import type { SqliteEventStore } from "@codebridge/work-items";
+import type { Hono } from "hono";
+export interface SessionRuntimeApiOptions {
+    catalog: SessionCatalogStore;
+    workItems: SqliteEventStore;
+    coordinator?: SessionCoordinator;
+    executor?: RunExecutor;
+    capabilities?: CapabilityRegistry;
+    channelOriginToken?: string;
+}
+export declare function registerSessionRuntimeCommandRoutes(app: Hono, options: SessionRuntimeApiOptions & {
+    coordinator: SessionCoordinator;
+}): void;
+export declare function registerSessionRuntimeReadRoutes(app: Hono, options: SessionRuntimeApiOptions): void;
+//# sourceMappingURL=session-runtime-api.d.ts.map

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

@@ -0,0 +1,453 @@
+import { SessionCommandError } from "@codebridge/session-coordinator";
+import { streamSSE } from "hono/streaming";
+import { randomUUID } from "node:crypto";
+import { toApiRun, toApiSession, toApiSessionEvent, toApiSessionTurn, toApiTimeline, } from "./session-runtime-types.js";
+export function registerSessionRuntimeCommandRoutes(app, options) {
+    app.post("/v1/sessions/:session_id/messages", async (c) => {
+        const session = options.catalog.getSession(c.req.param("session_id"));
+        if (!session)
+            return c.json({ error: "session_not_found" }, 404);
+        const key = c.req.header("idempotency-key");
+        if (!key)
+            return c.json({ error: "idempotency_key_required" }, 400);
+        const body = await c.req.json().catch(() => null);
+        if (!body || typeof body.message !== "string" || !body.message.trim()) {
+            return c.json({ error: "message_required" }, 400);
+        }
+        const attachments = parseAttachments(body.attachments);
+        if (!attachments)
+            return c.json({ error: "invalid_attachments" }, 400);
+        const dryRun = false;
+        const origin = options.channelOriginToken
+            && c.req.header("x-codebridge-channel-origin") === options.channelOriginToken
+            ? "channel" : "web";
+        const delivery = parseDelivery(body.delivery);
+        if (delivery === null) {
+            return c.json({ error: "invalid_delivery" }, 400);
+        }
+        try {
+            const result = options.coordinator.submitTurn({
+                sessionId: session.id,
+                idempotencyKey: key,
+                attachments,
+                message: {
+                    text: body.message,
+                    attachmentIds: [],
+                    model: nullable(body.model, session.model),
+                    effort: nullable(body.effort, session.effort),
+                    permissionMode: nullable(body.permission_mode, session.permissionMode),
+                    actorRef: origin === "web"
+                        ? { channel: "web", id: "local" }
+                        : channelActorRef(body.actor_ref),
+                    executionKind: "agent",
+                    plan: null,
+                },
+                workItem: {
+                    title: body.message.slice(0, 80),
+                    mode: "auto",
+                    conversationId: `conv_${session.id.replace(/^sess_/, "")}`,
+                    agentId: session.agentId,
+                    workspaceScope: session.cwd ? [session.cwd] : [],
+                    riskLevel: "read_only",
+                },
+                delivery,
+            });
+            options.catalog.updateSession(session.id, {
+                taskRecordId: result.workItemId,
+                model: result.turn.message.model,
+                effort: result.turn.message.effort,
+                permissionMode: result.turn.message.permissionMode,
+                title: session.title ?? body.message.slice(0, 80),
+                status: "active",
+            });
+            if (result.run) {
+                await observeExecution(options, result.run.id, dryRun, false);
+            }
+            return c.json(toSubmitReceipt(options, result), 202);
+        }
+        catch (error) {
+            return commandError(c, options, error);
+        }
+    });
+    app.get("/v1/sessions/:session_id/submissions/:idempotency_key", (c) => {
+        const result = options.workItems.getIdempotencyResponse(`session:message:${c.req.param("session_id")}`, c.req.param("idempotency_key"));
+        return result
+            ? c.json(toSubmitReceipt(options, result))
+            : c.json({ error: "submission_not_found" }, 404);
+    });
+    app.delete("/v1/sessions/:session_id/queue/:turn_id", (c) => {
+        const headers = commandHeaders(c);
+        if ("error" in headers)
+            return c.json({ error: headers.error }, headers.status);
+        try {
+            const result = options.coordinator.cancelQueuedTurn({
+                sessionId: c.req.param("session_id"),
+                turnId: c.req.param("turn_id"),
+                expectedVersion: headers.version,
+                idempotencyKey: headers.key,
+            });
+            return c.json({
+                turn: toApiSessionTurn(result.turn),
+                runtime: runtimeView(options, c.req.param("session_id")),
+            });
+        }
+        catch (error) {
+            return commandError(c, options, error);
+        }
+    });
+    app.post("/v1/sessions/:session_id/queue/resume", (c) => {
+        const headers = commandHeaders(c);
+        if ("error" in headers)
+            return c.json({ error: headers.error }, headers.status);
+        try {
+            const result = options.coordinator.resumeQueue({
+                sessionId: c.req.param("session_id"),
+                expectedRuntimeVersion: headers.version,
+                idempotencyKey: headers.key,
+            });
+            if (result.dispatched) {
+                observeExecution(options, result.dispatched.run.id);
+            }
+            return c.json({
+                runtime: runtimeView(options, c.req.param("session_id")),
+            });
+        }
+        catch (error) {
+            return commandError(c, options, error);
+        }
+    });
+    app.post("/v1/runs/:run_id/cancel", (c) => {
+        const headers = commandHeaders(c);
+        if ("error" in headers)
+            return c.json({ error: headers.error }, headers.status);
+        const run = options.workItems.getRun(c.req.param("run_id"));
+        if (!run?.sessionId)
+            return c.json({ error: "run_not_found" }, 404);
+        try {
+            const result = options.coordinator.requestRunCancellation({
+                sessionId: run.sessionId,
+                runId: run.id,
+                expectedRuntimeVersion: headers.version,
+                idempotencyKey: headers.key,
+            });
+            if (result.disposition === "interrupting") {
+                void options.executor?.cancelRunAndWait(run.id).catch(() => { });
+            }
+            return c.json({
+                disposition: result.disposition,
+                run: toApiRun(result.run, run.sessionId),
+            }, result.disposition === "interrupting" ? 202 : 200);
+        }
+        catch (error) {
+            return commandError(c, options, error);
+        }
+    });
+    app.post("/v1/sessions/:session_id/runs", (c) => c.json({
+        error: "run_creation_moved",
+        message: "POST /messages now creates or queues the Run atomically",
+    }, 410));
+}
+export function registerSessionRuntimeReadRoutes(app, options) {
+    app.get("/v1/sessions/:session_id", (c) => {
+        const session = options.catalog.getSession(c.req.param("session_id"));
+        if (!session)
+            return c.json({ error: "session_not_found" }, 404);
+        const runtime = options.workItems.getSessionRuntime(session.id);
+        const activeRun = runtime?.activeRunId
+            ? options.workItems.getRun(runtime.activeRunId)
+            : undefined;
+        const queue = options.workItems.listQueuedTurns(session.id, {
+            limit: 100,
+        });
+        const timeline = options.workItems.listTimelineTurns(session.id, {
+            limit: 50,
+            contentBudgetBytes: 1_048_576,
+        });
+        const workItem = options.workItems.getWorkItemBySessionId(session.id);
+        return c.json({
+            session: toApiSession({
+                ...session,
+                taskRecordId: session.taskRecordId ?? workItem?.id ?? null,
+            }),
+            runtime: {
+                active_run: activeRun ? toApiRun(activeRun, session.id) : null,
+                queue_state: runtime?.queueState ?? "ready",
+                queue_pause_reason: runtime?.queuePauseReason ?? null,
+                queue: {
+                    turns: queue.turns.map(toApiSessionTurn),
+                    total: queue.total,
+                    next_cursor: queue.nextCursor,
+                },
+                version: runtime?.version ?? 1,
+                last_event_sequence: runtime?.lastEventSequence ?? 0,
+            },
+            timeline: toApiTimeline(timeline),
+            commands: options.workItems.listSessionCommands(session.id),
+        });
+    });
+    app.get("/v1/sessions/:session_id/timeline", (c) => {
+        if (!options.catalog.getSession(c.req.param("session_id"))) {
+            return c.json({ error: "session_not_found" }, 404);
+        }
+        return c.json(toApiTimeline(options.workItems.listTimelineTurns(c.req.param("session_id"), {
+            before: integerQuery(c.req.query("before")),
+            limit: integerQuery(c.req.query("limit")) ?? 50,
+            contentBudgetBytes: 1_048_576,
+        })));
+    });
+    app.get("/v1/sessions/:session_id/blocks/:block_id/segments", (c) => {
+        if (!options.catalog.getSession(c.req.param("session_id"))) {
+            return c.json({ error: "session_not_found" }, 404);
+        }
+        const page = options.workItems.listTimelineSegments(c.req.param("block_id"), {
+            after: integerQuery(c.req.query("after")),
+            limit: integerQuery(c.req.query("limit")) ?? 100,
+        });
+        return c.json({
+            segments: page.segments.map((segment) => ({
+                segment_id: segment.segmentId,
+                segment_index: segment.segmentIndex,
+                content: segment.content,
+                byte_length: segment.byteLength,
+                sealed: segment.sealed,
+            })),
+            next_cursor: page.nextCursor,
+        });
+    });
+    app.get("/v1/sessions/:session_id/queue", (c) => {
+        if (!options.catalog.getSession(c.req.param("session_id"))) {
+            return c.json({ error: "session_not_found" }, 404);
+        }
+        const page = options.workItems.listQueuedTurns(c.req.param("session_id"), {
+            afterPosition: integerQuery(c.req.query("after_position")),
+            limit: integerQuery(c.req.query("limit")) ?? 100,
+        });
+        return c.json({
+            turns: page.turns.map(toApiSessionTurn),
+            total: page.total,
+            next_cursor: page.nextCursor,
+        });
+    });
+    app.get("/v1/sessions/:session_id/events", (c) => {
+        const session = options.catalog.getSession(c.req.param("session_id"));
+        if (!session)
+            return c.json({ error: "session_not_found" }, 404);
+        let workItem = options.workItems.getWorkItemBySessionId(session.id)
+            ?? (session.taskRecordId
+                ? options.workItems.getWorkItem(session.taskRecordId)
+                : undefined);
+        const after = integerQuery(c.req.query("after_sequence")) ?? 0;
+        if (c.req.query("live") === "true") {
+            return streamSSE(c, async (stream) => {
+                let cursor = after;
+                let aborted = false;
+                stream.onAbort(() => { aborted = true; });
+                while (!aborted) {
+                    workItem ??= options.workItems.getWorkItemBySessionId(session.id)
+                        ?? (options.catalog.getSession(session.id)?.taskRecordId
+                            ? options.workItems.getWorkItem(options.catalog.getSession(session.id).taskRecordId)
+                            : undefined);
+                    const candidates = workItem
+                        ? options.workItems.listEventsPage(workItem.id, cursor, 500)
+                        : [];
+                    let bytes = 0;
+                    let wrote = false;
+                    for (const event of candidates) {
+                        const data = JSON.stringify(toApiSessionEvent(event));
+                        const size = Buffer.byteLength(data, "utf8");
+                        if (wrote && bytes + size > 1_048_576)
+                            break;
+                        await stream.writeSSE({
+                            id: String(event.sequence),
+                            event: "session_event",
+                            data,
+                        });
+                        cursor = event.sequence;
+                        bytes += size;
+                        wrote = true;
+                    }
+                    if (!wrote)
+                        await stream.sleep(250);
+                }
+            });
+        }
+        if (!workItem) {
+            return c.json({
+                events: [],
+                next_sequence: after,
+                has_more: false,
+            });
+        }
+        const tail = integerQuery(c.req.query("tail"));
+        if (tail !== undefined) {
+            const events = options.workItems.listRecentEvents(workItem.id, Math.min(500, Math.max(1, tail)));
+            return c.json({
+                events: events.map(toApiSessionEvent),
+                next_sequence: events.at(-1)?.sequence ?? after,
+                has_more: false,
+            });
+        }
+        {
+            const requested = integerQuery(c.req.query("limit")) ?? 500;
+            const limit = Math.min(500, Math.max(1, requested));
+            const rows = options.workItems.listEventsPage(workItem.id, after, limit + 1);
+            const events = rows.slice(0, limit);
+            return c.json({
+                events: events.map(toApiSessionEvent),
+                next_sequence: events.at(-1)?.sequence ?? after,
+                has_more: rows.length > events.length,
+            });
+        }
+    });
+}
+function integerQuery(value) {
+    if (value === undefined || !/^-?\d+$/.test(value))
+        return undefined;
+    return Number(value);
+}
+function nullable(value, fallback) {
+    return value === undefined
+        ? fallback
+        : typeof value === "string"
+            ? value
+            : null;
+}
+function channelActorRef(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const actor = value;
+    if ((actor.channel !== "feishu" && actor.channel !== "telegram")
+        || typeof actor.id !== "string"
+        || !actor.id.trim()) {
+        return undefined;
+    }
+    return { channel: actor.channel, id: actor.id.trim() };
+}
+function parseDelivery(value) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object")
+        return null;
+    const delivery = value;
+    if (typeof delivery.channel !== "string"
+        || typeof delivery.conversation_id !== "string"
+        || typeof delivery.reply_to_message_id !== "string"
+        || typeof delivery.show_thinking !== "boolean") {
+        return null;
+    }
+    return {
+        channel: delivery.channel,
+        conversationId: delivery.conversation_id,
+        replyToMessageId: delivery.reply_to_message_id,
+        showThinking: delivery.show_thinking,
+    };
+}
+function parseAttachments(value) {
+    if (value === undefined)
+        return [];
+    if (!Array.isArray(value))
+        return null;
+    const result = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object")
+            return null;
+        const attachment = item;
+        const name = attachment.name;
+        const mimeType = attachment.mime_type ?? attachment.mimeType;
+        const dataBase64 = attachment.data_base64 ?? attachment.dataBase64;
+        if (typeof name !== "string"
+            || typeof mimeType !== "string"
+            || typeof dataBase64 !== "string") {
+            return null;
+        }
+        result.push({
+            id: `att_${randomUUID().replaceAll("-", "")}`,
+            name,
+            mimeType,
+            dataBase64,
+        });
+    }
+    return result;
+}
+function runtimeView(options, sessionId) {
+    const runtime = options.workItems.getSessionRuntime(sessionId);
+    const activeRun = runtime?.activeRunId
+        ? options.workItems.getRun(runtime.activeRunId)
+        : undefined;
+    const queue = options.workItems.listQueuedTurns(sessionId, {
+        limit: 100,
+    });
+    return {
+        active_run: activeRun ? toApiRun(activeRun, sessionId) : null,
+        queue_state: runtime?.queueState ?? "ready",
+        queue_pause_reason: runtime?.queuePauseReason ?? null,
+        queue: {
+            turns: queue.turns.map(toApiSessionTurn),
+            total: queue.total,
+            next_cursor: queue.nextCursor,
+        },
+        version: runtime?.version ?? 1,
+        last_event_sequence: runtime?.lastEventSequence ?? 0,
+    };
+}
+function toSubmitReceipt(options, result) {
+    return {
+        acceptance: result.acceptance,
+        run_id: result.run?.id ?? null,
+        turn: toApiSessionTurn(result.turn),
+        runtime: runtimeView(options, result.turn.sessionId),
+    };
+}
+function commandHeaders(c) {
+    const key = c.req.header("idempotency-key");
+    if (!key)
+        return { error: "idempotency_key_required", status: 400 };
+    const raw = c.req.header("if-match");
+    if (!raw || !/^\d+$/.test(raw)) {
+        return { error: "if_match_required", status: 428 };
+    }
+    return { key, version: Number(raw) };
+}
+function commandError(c, options, error) {
+    if (!(error instanceof SessionCommandError))
+        throw error;
+    const payload = { error: error.code };
+    if (error.code === "turn_version_conflict") {
+        const turnId = c.req.param("turn_id");
+        payload.turn = turnId
+            ? options.workItems.getTurn(turnId)
+            : undefined;
+    }
+    if (error.code === "runtime_version_conflict") {
+        const runId = c.req.param("run_id");
+        const sessionId = c.req.param("session_id")
+            || (runId ? options.workItems.getRun(runId)?.sessionId : null);
+        if (sessionId)
+            payload.runtime = runtimeView(options, sessionId);
+    }
+    if (error.status === 404)
+        return c.json(payload, 404);
+    if (error.status === 409)
+        return c.json(payload, 409);
+    return c.json(payload, 422);
+}
+async function observeExecution(options, runId, dryRun, wait = false) {
+    const execution = options.executor?.execute(runId, undefined, { dryRun });
+    if (!execution)
+        return;
+    if (!wait) {
+        void execution.catch(() => { });
+        return;
+    }
+    try {
+        await execution;
+    }
+    catch (error) {
+        const run = options.workItems.getRun(runId);
+        if (run && ["failed", "succeeded", "cancelled", "interrupted"].includes(run.status)) {
+            return;
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=session-runtime-api.js.map

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

@@ -0,0 +1,21 @@
+import type { SessionCatalogStore } from "@codebridge/session-catalog";
+import type { SqliteEventStore } from "@codebridge/work-items";
+export interface SessionRuntimeMigrationConflict {
+    sessionId: string;
+    activeRunIds: string[];
+}
+export interface SessionRuntimeMigrationResult {
+    migratedSessions: number;
+    projectedEvents: number;
+    conflicts: SessionRuntimeMigrationConflict[];
+}
+export declare class SessionRuntimeMigration {
+    private readonly catalog;
+    private readonly store;
+    constructor(catalog: SessionCatalogStore, store: SqliteEventStore);
+    run(options: {
+        batchSize: number;
+        maximumBatches?: number;
+    }): SessionRuntimeMigrationResult;
+}
+//# sourceMappingURL=session-runtime-migration.d.ts.map

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

@@ -0,0 +1,43 @@
+export class SessionRuntimeMigration {
+    catalog;
+    store;
+    constructor(catalog, store) {
+        this.catalog = catalog;
+        this.store = store;
+    }
+    run(options) {
+        const bindings = this.catalog
+            .listSessions(undefined, { includeArchived: true })
+            .filter((session) => session.taskRecordId)
+            .map((session) => ({
+            sessionId: session.id,
+            workItemId: session.taskRecordId,
+        }));
+        const preview = this.store.previewSessionRuntimeMigration(bindings);
+        if (preview.conflicts.length) {
+            const error = new Error("session_runtime_migration_conflict");
+            error.conflicts = preview.conflicts;
+            throw error;
+        }
+        let projectedEvents = 0;
+        let batches = 0;
+        for (const binding of bindings) {
+            this.store.bindWorkItemToSession(binding.sessionId, binding.workItemId);
+            this.store.backfillRunTurns(binding.sessionId, binding.workItemId);
+            this.store.ensureRuntimeFromRuns(binding.sessionId);
+            while (batches < (options.maximumBatches ?? Number.POSITIVE_INFINITY)) {
+                const count = this.store.backfillSessionProjection(binding.sessionId, binding.workItemId, options.batchSize);
+                if (!count)
+                    break;
+                projectedEvents += count;
+                batches += 1;
+            }
+        }
+        return {
+            migratedSessions: bindings.length,
+            projectedEvents,
+            conflicts: [],
+        };
+    }
+}
+//# sourceMappingURL=session-runtime-migration.js.map