@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/work-items/dist/session-projector.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { DomainEvent } from "./index.js";
+export declare function projectSessionEvent(database: DatabaseSync, sessionId: string, event: DomainEvent): void;
+//# sourceMappingURL=session-projector.d.ts.map

package/node_modules/@codebridge/work-items/dist/session-projector.js

@@ -0,0 +1,506 @@
+const MAX_SEGMENT_BYTES = 16 * 1_024;
+export function projectSessionEvent(database, sessionId, event) {
+    const cursor = database
+        .prepare(`SELECT last_projected_sequence
+       FROM session_projection_cursors
+       WHERE session_id = ?`)
+        .get(sessionId);
+    if ((cursor?.last_projected_sequence ?? 0) >= event.sequence)
+        return;
+    switch (event.type) {
+        case "TURN_DISPATCHED":
+            projectTurnDispatched(database, sessionId, event);
+            break;
+        case "MESSAGE_RECEIVED":
+            projectUserMessage(database, sessionId, event);
+            break;
+        case "RUN_STARTED":
+            updateTurnStatus(database, event.runId, "running", event);
+            ensureBlock(database, sessionId, event, `work:${event.runId}`, "work", "running");
+            break;
+        case "AGENT_EVENT":
+            projectAgentEvent(database, sessionId, event);
+            break;
+        case "APPROVAL_REQUESTED":
+            updateTurnStatus(database, event.runId, "waiting", event);
+            ensureBlock(database, sessionId, event, approvalBlockId(event), "approval", "waiting", {
+                ...event.payload,
+                capability_id: event.target,
+            });
+            break;
+        case "APPROVAL_GRANTED":
+            updateApprovalBlock(database, event, "granted");
+            break;
+        case "APPROVAL_REJECTED":
+            updateApprovalBlock(database, event, "rejected");
+            break;
+        case "RUN_SUCCEEDED":
+            closeRun(database, event, "succeeded");
+            break;
+        case "RUN_FAILED":
+            closeRun(database, event, "failed");
+            break;
+        case "RUN_CANCELLED":
+            closeRun(database, event, "cancelled");
+            break;
+        case "RUN_INTERRUPTED":
+            closeRun(database, event, "interrupted");
+            break;
+        case "TURN_CANCELLED":
+            assertQueuedTurnHasNoTimeline(database, String(event.target));
+            break;
+        // Agent-emitted step events advance the cursor without creating controls.
+        case "STEP_STARTED":
+        case "STEP_RETRYING":
+        case "STEP_SUCCEEDED":
+        case "STEP_FAILED":
+        case "STEP_SKIPPED":
+            break;
+        // 已知但有意不进时间线的类型：显式 no-op（cursor 正常前进）。
+        case "WORK_ITEM_CREATED":
+        case "TURN_QUEUED":
+        case "RUN_CREATED":
+        case "PLAN_VALIDATED":
+        case "RUN_CANCEL_REQUESTED":
+        case "BRANCH_SELECTED":
+        case "PROJECT_CANDIDATE_FOUND":
+        case "ARTIFACT_CREATED":
+        case "VERIFICATION_COMPLETED":
+        case "WORK_ITEM_COMPLETED":
+        // 迁移/水合/学习信号事件：绑定前写下的历史事件会经 backfillSessionProjection
+        // 走投影，显式 no-op（否则回放命中 default 会打挂迁移）。
+        case "SESSION_HISTORY_HYDRATED":
+        case "PLAN_PROPOSED":
+        case "DISCOVERY_STARTED":
+            break;
+        default:
+            // R2：未知事件不得静默跳过——抛错后 cursor 停在旧 sequence，
+            // 修复投影后才能重放（appendEvent 整笔回滚）。
+            throw new Error(`Unsupported session projection event type: ${event.type}`);
+    }
+    database
+        .prepare(`INSERT INTO session_projection_cursors(
+        session_id, last_projected_sequence
+      ) VALUES (?, ?)
+      ON CONFLICT(session_id) DO UPDATE SET
+        last_projected_sequence = excluded.last_projected_sequence`)
+        .run(sessionId, event.sequence);
+}
+function projectTurnDispatched(database, sessionId, event) {
+    const runId = requireRunId(event);
+    const turnId = typeof event.payload.turn_id === "string"
+        ? event.payload.turn_id
+        : String(event.target);
+    const row = database
+        .prepare(`SELECT COALESCE(MAX(timeline_index), 0) + 1 AS next_index
+       FROM session_timeline_turns
+       WHERE session_id = ?`)
+        .get(sessionId);
+    database
+        .prepare(`INSERT INTO session_timeline_turns (
+        session_id, timeline_index, turn_id, run_id, started_sequence,
+        ended_sequence, status, updated_at
+      ) VALUES (?, ?, ?, ?, ?, NULL, 'dispatched', ?)`)
+        .run(sessionId, Number(row?.next_index ?? 1), turnId, runId, event.sequence, event.occurredAt);
+}
+function projectUserMessage(database, sessionId, event) {
+    const runId = requireRunId(event);
+    const turn = findTimelineTurn(database, runId);
+    if (!turn)
+        throw new Error(`Timeline Turn not found for Run: ${runId}`);
+    const blockId = `user:${String(turn.turn_id)}`;
+    ensureBlock(database, sessionId, event, blockId, "user_message", "completed", {
+        attachment_ids: Array.isArray(event.payload.attachment_ids)
+            ? event.payload.attachment_ids
+            : [],
+    });
+    appendSegment(database, blockId, typeof event.payload.message === "string"
+        ? event.payload.message
+        : "", true);
+}
+function projectAgentEvent(database, sessionId, event) {
+    const value = event.payload.event;
+    if (!value || typeof value !== "object")
+        return;
+    const agentEvent = value;
+    const type = typeof agentEvent.type === "string"
+        ? agentEvent.type
+        : "";
+    if (type === "available_commands_update") {
+        projectCommands(database, sessionId, event.sequence, agentEvent);
+        return;
+    }
+    if (type === "text_delta" || type === "thought_delta") {
+        const runId = requireRunId(event);
+        const phase = agentEvent.phase === "commentary"
+            ? "commentary"
+            : "final_answer";
+        const kind = type === "thought_delta"
+            ? "thought"
+            : phase === "commentary"
+                ? "work"
+                : "assistant";
+        if (kind !== "thought") {
+            completeOpenThoughtBlocks(database, runId, event.occurredAt);
+        }
+        const turn = findTimelineTurn(database, runId);
+        if (!turn)
+            throw new Error(`Timeline Turn not found for Run: ${runId}`);
+        const blockId = kind === "thought"
+            ? resolveThoughtBlockId(database, runId, event, agentEvent)
+            : stringValue(agentEvent.blockId)
+                ?? stringValue(agentEvent.messageId)
+                ?? `${runId}:${phase}`;
+        ensureBlock(database, sessionId, event, blockId, kind, "running", { phase }, kind === "thought"
+            ? thoughtInsertIndex(database, String(turn.turn_id))
+            : undefined);
+        appendSegment(database, blockId, typeof agentEvent.text === "string" ? agentEvent.text : "", false);
+        return;
+    }
+    if (type === "tool_start"
+        || type === "tool_update"
+        || type === "tool_end") {
+        const runId = requireRunId(event);
+        const toolCallId = stringValue(agentEvent.toolCallId)
+            ?? `${runId}:tool:${event.sequence}`;
+        const blockId = `tool:${toolCallId}`;
+        if (type === "tool_start") {
+            completeOpenThoughtBlocks(database, runId, event.occurredAt);
+            sealOpenSegmentsForRun(database, runId);
+            ensureBlock(database, sessionId, event, blockId, "tool", "running", agentEvent);
+            return;
+        }
+        updateToolBlock(database, blockId, agentEvent, type === "tool_end");
+        return;
+    }
+    if (type === "error") {
+        const runId = requireRunId(event);
+        const message = typeof agentEvent.message === "string"
+            ? agentEvent.message
+            : "";
+        if (!message)
+            return;
+        const blockId = `error:${runId}:${event.sequence}`;
+        ensureBlock(database, sessionId, event, blockId, "error", "failed");
+        appendSegment(database, blockId, message, true);
+    }
+}
+function projectCommands(database, sessionId, sequence, event) {
+    const commands = Array.isArray(event.availableCommands)
+        ? event.availableCommands
+        : [];
+    database
+        .prepare("DELETE FROM session_commands WHERE session_id = ?")
+        .run(sessionId);
+    const insert = database.prepare(`INSERT INTO session_commands (
+      session_id, name, description, input_json, source_sequence
+    ) VALUES (?, ?, ?, ?, ?)`);
+    for (const value of commands) {
+        if (!value || typeof value !== "object")
+            continue;
+        const command = value;
+        if (typeof command.name !== "string"
+            || typeof command.description !== "string") {
+            continue;
+        }
+        const input = command.input && typeof command.input === "object"
+            ? command.input
+            : null;
+        insert.run(sessionId, command.name, command.description, input ? JSON.stringify(input) : null, sequence);
+    }
+}
+function updateTurnStatus(database, runId, status, event) {
+    if (!runId)
+        return;
+    database
+        .prepare(`UPDATE session_timeline_turns
+       SET status = ?, updated_at = ?
+       WHERE run_id = ?`)
+        .run(status, event.occurredAt, runId);
+}
+function ensureBlock(database, sessionId, event, blockId, kind, status, metadata = {}, insertIndex) {
+    const existing = database
+        .prepare("SELECT block_id FROM session_timeline_blocks WHERE block_id = ?")
+        .get(blockId);
+    if (existing)
+        return;
+    const runId = requireRunId(event);
+    const turn = findTimelineTurn(database, runId);
+    if (!turn)
+        throw new Error(`Timeline Turn not found for Run: ${runId}`);
+    const turnId = String(turn.turn_id);
+    const row = database
+        .prepare(`SELECT COALESCE(MAX(block_index), -1) + 1 AS next_index
+       FROM session_timeline_blocks
+       WHERE turn_id = ?`)
+        .get(turnId);
+    const appendIndex = Number(row?.next_index ?? 0);
+    const blockIndex = insertIndex ?? appendIndex;
+    if (blockIndex < appendIndex)
+        shiftBlockIndices(database, turnId, blockIndex);
+    database
+        .prepare(`INSERT INTO session_timeline_blocks (
+        block_id, session_id, turn_id, run_id, block_index, kind, status,
+        metadata_json
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(blockId, sessionId, turnId, runId, blockIndex, kind, status, JSON.stringify(boundMetadata({
+        ...metadata,
+        started_at: event.occurredAt,
+    })));
+}
+function resolveThoughtBlockId(database, runId, event, agentEvent) {
+    const running = database
+        .prepare(`SELECT block_id FROM session_timeline_blocks
+       WHERE run_id = ? AND kind = 'thought' AND status = 'running'
+       ORDER BY block_index DESC
+       LIMIT 1`)
+        .get(runId);
+    if (running?.block_id)
+        return String(running.block_id);
+    const explicit = stringValue(agentEvent.blockId)
+        ?? stringValue(agentEvent.messageId);
+    if (explicit) {
+        const existing = database
+            .prepare("SELECT status FROM session_timeline_blocks WHERE block_id = ?")
+            .get(explicit);
+        if (!existing || existing.status === "running")
+            return explicit;
+    }
+    return `${runId}:thought:${event.sequence}`;
+}
+function thoughtInsertIndex(database, turnId) {
+    const lastThought = database
+        .prepare(`SELECT MAX(block_index) AS idx FROM session_timeline_blocks
+       WHERE turn_id = ? AND kind = 'thought'`)
+        .get(turnId);
+    if (lastThought?.idx != null)
+        return Number(lastThought.idx) + 1;
+    const append = database
+        .prepare(`SELECT COALESCE(MAX(block_index), -1) + 1 AS next_index
+       FROM session_timeline_blocks
+       WHERE turn_id = ?`)
+        .get(turnId);
+    return Number(append?.next_index ?? 0);
+}
+function shiftBlockIndices(database, turnId, fromIndex) {
+    const rows = database
+        .prepare(`SELECT block_id, block_index FROM session_timeline_blocks
+       WHERE turn_id = ? AND block_index >= ?
+       ORDER BY block_index DESC`)
+        .all(turnId, fromIndex);
+    const update = database.prepare("UPDATE session_timeline_blocks SET block_index = ? WHERE block_id = ?");
+    for (const row of rows) {
+        update.run(Number(row.block_index) + 1, row.block_id);
+    }
+}
+function completeOpenThoughtBlocks(database, runId, endedAt) {
+    const rows = database
+        .prepare(`SELECT block_id, metadata_json FROM session_timeline_blocks
+       WHERE run_id = ? AND kind = 'thought' AND status = 'running'`)
+        .all(runId);
+    const update = database.prepare(`UPDATE session_timeline_blocks
+     SET status = ?, metadata_json = ?
+     WHERE block_id = ?`);
+    for (const row of rows) {
+        const metadata = JSON.parse(row.metadata_json ?? "{}");
+        update.run("completed", JSON.stringify(boundMetadata({ ...metadata, ended_at: endedAt })), row.block_id);
+        database
+            .prepare(`UPDATE session_output_segments
+         SET sealed = 1
+         WHERE block_id = ? AND sealed = 0`)
+            .run(row.block_id);
+    }
+}
+function appendSegment(database, blockId, text, sealAfter) {
+    let remaining = text;
+    while (remaining) {
+        let tail = database
+            .prepare(`SELECT * FROM session_output_segments
+         WHERE block_id = ?
+         ORDER BY segment_index DESC
+         LIMIT 1`)
+            .get(blockId);
+        if (!tail || Number(tail.sealed) === 1) {
+            const nextIndex = tail ? Number(tail.segment_index) + 1 : 0;
+            const segmentId = `${blockId}:${nextIndex}`;
+            database
+                .prepare(`INSERT INTO session_output_segments (
+            segment_id, block_id, segment_index, content, byte_length, sealed
+          ) VALUES (?, ?, ?, '', 0, 0)`)
+                .run(segmentId, blockId, nextIndex);
+            tail = database
+                .prepare("SELECT * FROM session_output_segments WHERE segment_id = ?")
+                .get(segmentId);
+        }
+        const current = String(tail.content);
+        const currentBytes = Number(tail.byte_length);
+        const capacity = MAX_SEGMENT_BYTES - currentBytes;
+        const { head, tail: rest } = splitUtf8(remaining, capacity);
+        const nextContent = current + head;
+        const nextBytes = Buffer.byteLength(nextContent, "utf8");
+        const sealed = rest.length > 0 || nextBytes >= MAX_SEGMENT_BYTES;
+        database
+            .prepare(`UPDATE session_output_segments
+         SET content = ?, byte_length = ?, sealed = ?
+         WHERE segment_id = ?`)
+            .run(nextContent, nextBytes, sealed ? 1 : 0, String(tail.segment_id));
+        remaining = rest;
+    }
+    if (sealAfter) {
+        database
+            .prepare(`UPDATE session_output_segments
+         SET sealed = 1
+         WHERE block_id = ? AND sealed = 0`)
+            .run(blockId);
+    }
+}
+function updateToolBlock(database, blockId, update, ended) {
+    const row = database
+        .prepare(`SELECT metadata_json FROM session_timeline_blocks
+       WHERE block_id = ?`)
+        .get(blockId);
+    if (!row)
+        return;
+    const current = JSON.parse(row.metadata_json ?? "{}");
+    const status = ended
+        ? update.status === "failed"
+            ? "failed"
+            : "completed"
+        : "running";
+    database
+        .prepare(`UPDATE session_timeline_blocks
+       SET status = ?, metadata_json = ?
+       WHERE block_id = ?`)
+        .run(status, JSON.stringify(boundMetadata({ ...current, ...update })), blockId);
+}
+function closeRun(database, event, status) {
+    const runId = requireRunId(event);
+    const nextStatus = status === "succeeded" ? "completed" : status;
+    database
+        .prepare(`UPDATE session_timeline_turns
+       SET status = ?, ended_sequence = ?, updated_at = ?
+       WHERE run_id = ?`)
+        .run(status, event.sequence, event.occurredAt, runId);
+    const openBlocks = database
+        .prepare(`SELECT block_id, metadata_json FROM session_timeline_blocks
+       WHERE run_id = ? AND status IN ('running', 'waiting')`)
+        .all(runId);
+    const updateBlock = database.prepare(`UPDATE session_timeline_blocks
+     SET status = ?, metadata_json = ?
+     WHERE block_id = ?`);
+    for (const block of openBlocks) {
+        const metadata = JSON.parse(block.metadata_json ?? "{}");
+        updateBlock.run(nextStatus, JSON.stringify(boundMetadata({ ...metadata, ended_at: event.occurredAt })), block.block_id);
+    }
+    sealOpenSegmentsForRun(database, runId);
+}
+function sealOpenSegmentsForRun(database, runId) {
+    database
+        .prepare(`UPDATE session_output_segments
+       SET sealed = 1
+       WHERE sealed = 0 AND block_id IN (
+         SELECT block_id FROM session_timeline_blocks WHERE run_id = ?
+       )`)
+        .run(runId);
+}
+function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+}
+function approvalIdOf(event) {
+    const approvalId = asRecord(event.payload).approval_id;
+    if (typeof approvalId !== "string" || !approvalId) {
+        throw new Error(`Approval event missing approval_id: ${event.eventId}`);
+    }
+    return approvalId;
+}
+function approvalBlockId(event) {
+    return `approval:${approvalIdOf(event)}`;
+}
+function updateApprovalBlock(database, event, status) {
+    const preferredBlockId = approvalBlockId(event);
+    const legacyBlockId = event.target ? `approval:${event.target}` : null;
+    const candidates = legacyBlockId
+        ? [preferredBlockId, legacyBlockId]
+        : [preferredBlockId];
+    let blockId = null;
+    let metadata = {};
+    for (const candidate of candidates) {
+        const row = database
+            .prepare(`SELECT metadata_json FROM session_timeline_blocks
+         WHERE block_id = ?`)
+            .get(candidate);
+        if (!row)
+            continue;
+        blockId = candidate;
+        metadata = JSON.parse(row.metadata_json ?? "{}");
+        break;
+    }
+    if (!blockId)
+        return;
+    database
+        .prepare(`UPDATE session_timeline_blocks
+       SET status = ?, metadata_json = ?
+       WHERE block_id = ?`)
+        .run(status, JSON.stringify(boundMetadata({
+        ...metadata,
+        ...event.payload,
+        capability_id: event.target ?? metadata.capability_id ?? null,
+        resolved_at: event.occurredAt,
+    })), blockId);
+}
+function assertQueuedTurnHasNoTimeline(database, turnId) {
+    const turn = database
+        .prepare("SELECT status FROM session_turns WHERE turn_id = ?")
+        .get(turnId);
+    if (turn?.status === "dispatched") {
+        throw new Error("dispatched Turn cannot be cancelled");
+    }
+    const timeline = database
+        .prepare("SELECT 1 FROM session_timeline_turns WHERE turn_id = ? LIMIT 1")
+        .get(turnId);
+    if (timeline)
+        throw new Error("queued Turn cannot have a timeline");
+}
+function findTimelineTurn(database, runId) {
+    return database
+        .prepare("SELECT * FROM session_timeline_turns WHERE run_id = ?")
+        .get(runId);
+}
+function requireRunId(event) {
+    if (!event.runId) {
+        throw new Error(`${event.type} requires a Run`);
+    }
+    return event.runId;
+}
+function stringValue(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function splitUtf8(value, maximumBytes) {
+    if (maximumBytes <= 0)
+        return { head: "", tail: value };
+    let bytes = 0;
+    let end = 0;
+    for (const character of value) {
+        const characterBytes = Buffer.byteLength(character, "utf8");
+        if (bytes + characterBytes > maximumBytes)
+            break;
+        bytes += characterBytes;
+        end += character.length;
+    }
+    return { head: value.slice(0, end), tail: value.slice(end) };
+}
+function boundMetadata(metadata) {
+    const serialized = JSON.stringify(metadata);
+    if (Buffer.byteLength(serialized, "utf8") <= MAX_SEGMENT_BYTES) {
+        return metadata;
+    }
+    return {
+        type: metadata.type,
+        name: metadata.name,
+        status: metadata.status,
+        truncated: true,
+    };
+}
+//# sourceMappingURL=session-projector.js.map