@graychennpm/codebridge 0.0.0-stage → 0.1.0

package/node_modules/@codebridge/session-coordinator/dist/coordinator.js

@@ -0,0 +1,364 @@
+export class SessionCommandError extends Error {
+    code;
+    status;
+    constructor(code, status) {
+        super(code);
+        this.code = code;
+        this.status = status;
+    }
+}
+export class SessionCoordinator {
+    store;
+    options;
+    now;
+    constructor(store, options) {
+        this.store = store;
+        this.options = options;
+        this.now = options.now ?? (() => new Date());
+    }
+    submitTurn(input) {
+        const namespace = `session:message:${input.sessionId}`;
+        return this.store.withSessionTransaction((tx) => {
+            const prior = tx.getIdempotencyResponse(namespace, input.idempotencyKey);
+            if (prior)
+                return prior;
+            const workItemId = tx.getOrCreateWorkItem(input.sessionId, input.workItem);
+            const attachments = (input.attachments ?? []).map((attachment) => tx.insertMessageAttachment({
+                ...attachment,
+                workItemId,
+            }));
+            const persistedMessage = {
+                ...input.message,
+                attachmentIds: attachments.map((attachment) => attachment.id),
+            };
+            let runtime = tx.ensureRuntime(input.sessionId);
+            const queuedTurns = tx.countQueuedTurns(input.sessionId);
+            if (queuedTurns >= this.options.maxQueuedTurns) {
+                throw new SessionCommandError("queue_full", 422);
+            }
+            if (runtime.activeRunId === null
+                && runtime.queueState === "paused"
+                && queuedTurns === 0) {
+                runtime = tx.updateRuntime(input.sessionId, {
+                    queueState: "ready",
+                    queuePauseReason: null,
+                });
+            }
+            const submitted = tx.insertTurn(input.sessionId, persistedMessage);
+            let turn = submitted;
+            let run = null;
+            if (runtime.activeRunId === null
+                && runtime.queueState === "ready") {
+                const dispatched = tx.dispatchNextTurn(input.sessionId);
+                turn = dispatched.turn.turnId === submitted.turnId
+                    ? dispatched.turn
+                    : submitted;
+                run = dispatched.run;
+            }
+            if (turn.status === "queued") {
+                tx.appendEvent({
+                    workItemId,
+                    sessionId: input.sessionId,
+                    type: "TURN_QUEUED",
+                    actor: "user",
+                    target: turn.turnId,
+                    payload: {
+                        queue_position: turn.queuePosition,
+                        actor_ref: turn.message.actorRef ?? null,
+                    },
+                });
+            }
+            runtime = tx.getRuntime(input.sessionId);
+            if (input.delivery) {
+                tx.insertChannelDelivery({
+                    turnId: submitted.turnId,
+                    sessionId: input.sessionId,
+                    channel: input.delivery.channel,
+                    conversationId: input.delivery.conversationId,
+                    replyToMessageId: input.delivery.replyToMessageId,
+                    showThinking: input.delivery.showThinking,
+                    acceptedSequence: runtime.lastEventSequence,
+                    runId: run?.id ?? null,
+                    status: run ? "dispatched" : "pending",
+                });
+            }
+            const result = {
+                acceptance: turn.status === "dispatched"
+                    ? "dispatched"
+                    : "queued",
+                turn,
+                run,
+                runtime,
+                workItemId,
+            };
+            tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+            return result;
+        });
+    }
+    finishRun(input) {
+        return this.store.withSessionTransaction((tx) => this.finishRunInTransaction(tx, input));
+    }
+    cancelQueuedTurn(input) {
+        const namespace = `session:queue-cancel:${input.sessionId}:${input.turnId}`;
+        return this.store.withSessionTransaction((tx) => {
+            const prior = tx.getIdempotencyResponse(namespace, input.idempotencyKey);
+            if (prior)
+                return prior;
+            const current = tx.getTurn(input.turnId);
+            if (!current || current.sessionId !== input.sessionId) {
+                throw new SessionCommandError("turn_not_found", 404);
+            }
+            if (current.status !== "queued") {
+                throw new SessionCommandError("turn_not_queued", 409);
+            }
+            if (current.version !== input.expectedVersion) {
+                throw new SessionCommandError("turn_version_conflict", 409);
+            }
+            const turn = tx.cancelTurn(input.turnId, input.expectedVersion);
+            if (!turn) {
+                throw new SessionCommandError("turn_version_conflict", 409);
+            }
+            const workItem = tx.getWorkItemForSession(input.sessionId);
+            if (!workItem) {
+                throw new SessionCommandError("turn_not_found", 404);
+            }
+            tx.appendEvent({
+                workItemId: workItem.id,
+                sessionId: input.sessionId,
+                type: "TURN_CANCELLED",
+                actor: "user",
+                target: turn.turnId,
+                payload: { queue_position: turn.queuePosition },
+            });
+            const result = {
+                turn,
+                runtime: tx.getRuntime(input.sessionId),
+            };
+            tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+            return result;
+        });
+    }
+    resumeQueue(input) {
+        const namespace = `session:queue-resume:${input.sessionId}`;
+        return this.store.withSessionTransaction((tx) => {
+            const prior = tx.getIdempotencyResponse(namespace, input.idempotencyKey);
+            if (prior)
+                return prior;
+            const runtime = tx.ensureRuntime(input.sessionId);
+            if (runtime.version !== input.expectedRuntimeVersion) {
+                throw new SessionCommandError("runtime_version_conflict", 409);
+            }
+            const activeRun = runtime.activeRunId
+                ? tx.getRun(runtime.activeRunId)
+                : undefined;
+            tx.updateRuntime(input.sessionId, {
+                queueState: "ready",
+                queuePauseReason: null,
+            });
+            let dispatched = null;
+            if (activeRun?.status === "queued" && activeRun.turnId) {
+                const turn = tx.getTurn(activeRun.turnId);
+                if (turn)
+                    dispatched = { turn, run: activeRun };
+            }
+            if (!dispatched) {
+                dispatched = tx.dispatchNextTurn(input.sessionId);
+            }
+            const result = {
+                runtime: tx.getRuntime(input.sessionId),
+                dispatched,
+            };
+            tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+            return result;
+        });
+    }
+    requestRunCancellation(input) {
+        const namespace = `session:run-cancel:${input.runId}`;
+        return this.store.withSessionTransaction((tx) => {
+            const prior = tx.getIdempotencyResponse(namespace, input.idempotencyKey);
+            if (prior)
+                return prior;
+            const run = tx.getRun(input.runId);
+            if (!run || run.sessionId !== input.sessionId) {
+                throw new SessionCommandError("active_run_mismatch", 409);
+            }
+            const runtime = tx.ensureRuntime(input.sessionId);
+            if (run.status === "succeeded"
+                || run.status === "failed"
+                || run.status === "cancelled"
+                || run.status === "interrupted") {
+                const result = {
+                    disposition: "already_terminal",
+                    run,
+                    runtime,
+                };
+                tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+                return result;
+            }
+            if (runtime.version !== input.expectedRuntimeVersion) {
+                throw new SessionCommandError("runtime_version_conflict", 409);
+            }
+            if (run.status === "queued" || run.status === "waiting") {
+                const finished = this.finishRunInTransaction(tx, {
+                    sessionId: input.sessionId,
+                    runId: input.runId,
+                    status: "cancelled",
+                    reason: "user_requested",
+                });
+                const result = {
+                    disposition: "cancelled",
+                    run: finished.run,
+                    runtime: finished.runtime,
+                };
+                tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+                return result;
+            }
+            let interruptingRun = run;
+            if (!run.cancelRequestedAt) {
+                const requestedAt = this.now();
+                interruptingRun = tx.updateRun(run.id, {
+                    cancelRequestedAt: requestedAt.toISOString(),
+                    cancelDeadlineAt: new Date(requestedAt.getTime() + 10_000).toISOString(),
+                });
+                tx.appendEvent({
+                    workItemId: run.workItemId,
+                    sessionId: input.sessionId,
+                    runId: run.id,
+                    type: "RUN_CANCEL_REQUESTED",
+                    actor: "user",
+                    target: run.id,
+                    payload: {
+                        deadline_at: interruptingRun.cancelDeadlineAt,
+                    },
+                });
+            }
+            const result = {
+                disposition: "interrupting",
+                run: interruptingRun,
+                runtime: tx.getRuntime(input.sessionId),
+            };
+            tx.putIdempotencyResponse(namespace, input.idempotencyKey, result);
+            return result;
+        });
+    }
+    repairRunFromTerminalEvidence(input) {
+        return this.store.withSessionTransaction((tx) => {
+            const runtime = tx.ensureRuntime(input.sessionId);
+            const existingRun = tx.getRun(input.runId);
+            if (runtime.activeRunId !== input.runId
+                || !existingRun
+                || existingRun.sessionId !== input.sessionId) {
+                throw new SessionCommandError("active_run_mismatch", 409);
+            }
+            const run = tx.updateRun(input.runId, {
+                status: input.status,
+                leaseOwner: null,
+                leaseExpiresAt: null,
+            });
+            let dispatched = null;
+            if (input.status === "succeeded") {
+                dispatched = this.advanceQueueAfterSuccess(tx, input.sessionId, runtime);
+            }
+            else {
+                tx.updateRuntime(input.sessionId, {
+                    activeRunId: null,
+                    queueState: "paused",
+                    queuePauseReason: input.status,
+                });
+            }
+            return {
+                runtime: tx.getRuntime(input.sessionId),
+                run,
+                dispatched,
+            };
+        });
+    }
+    pauseQueue(input) {
+        return this.store.withSessionTransaction((tx) => {
+            const runtime = tx.ensureRuntime(input.sessionId);
+            if (runtime.queueState === "paused")
+                return runtime;
+            return tx.updateRuntime(input.sessionId, {
+                queueState: "paused",
+                queuePauseReason: input.reason,
+            });
+        });
+    }
+    finishRunInTransaction(tx, input) {
+        const runtime = tx.ensureRuntime(input.sessionId);
+        if (runtime.activeRunId !== input.runId) {
+            throw new SessionCommandError("active_run_mismatch", 409);
+        }
+        const existingRun = tx.getRun(input.runId);
+        if (!existingRun || existingRun.sessionId !== input.sessionId) {
+            throw new SessionCommandError("active_run_mismatch", 409);
+        }
+        const run = tx.updateRun(input.runId, {
+            status: input.status,
+            terminalReason: input.reason ?? null,
+            leaseOwner: null,
+            leaseExpiresAt: null,
+        });
+        const eventType = {
+            succeeded: "RUN_SUCCEEDED",
+            failed: "RUN_FAILED",
+            cancelled: "RUN_CANCELLED",
+            interrupted: "RUN_INTERRUPTED",
+        };
+        tx.appendEvent({
+            workItemId: run.workItemId,
+            sessionId: input.sessionId,
+            runId: run.id,
+            type: eventType[input.status],
+            actor: "system",
+            payload: input.reason ? { reason: input.reason } : {},
+        });
+        tx.markDeliveryRunTerminal(input.runId, this.now().toISOString());
+        // 释放 Provider Session Lease（owner-conditional），且必须在 dispatchNextTurn 之前，
+        // 否则下一个 Run 会因旧 lease 仍被持有而 claim 失败。
+        if (run.providerSessionId && run.agentId) {
+            tx.releaseProviderSession({
+                agentId: run.agentId,
+                providerSessionId: run.providerSessionId,
+                runId: run.id,
+            });
+        }
+        let dispatched = null;
+        if (input.status === "cancelled" && (run.cancelRequestedAt || input.reason === "user_requested")) {
+            tx.updateRuntime(input.sessionId, {
+                activeRunId: null,
+                queueState: "ready",
+                queuePauseReason: null,
+            });
+            dispatched = tx.dispatchNextTurn(input.sessionId);
+        }
+        else if (input.status === "succeeded") {
+            dispatched = this.advanceQueueAfterSuccess(tx, input.sessionId, runtime);
+        }
+        else {
+            tx.updateRuntime(input.sessionId, {
+                activeRunId: null,
+                queueState: "paused",
+                queuePauseReason: input.status,
+            });
+        }
+        return {
+            runtime: tx.getRuntime(input.sessionId),
+            run,
+            dispatched,
+        };
+    }
+    advanceQueueAfterSuccess(tx, sessionId, runtime) {
+        if (runtime.queueState === "paused") {
+            tx.updateRuntime(sessionId, { activeRunId: null });
+            return null;
+        }
+        tx.updateRuntime(sessionId, {
+            activeRunId: null,
+            queueState: "ready",
+            queuePauseReason: null,
+        });
+        return tx.dispatchNextTurn(sessionId);
+    }
+}
+//# sourceMappingURL=coordinator.js.map

package/node_modules/@codebridge/session-coordinator/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./coordinator.js";
+export * from "./lease.js";
+export * from "./queued-claim.js";
+export * from "./recovery.js";
+//# sourceMappingURL=index.d.ts.map

package/node_modules/@codebridge/session-coordinator/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./coordinator.js";
+export * from "./lease.js";
+export * from "./queued-claim.js";
+export * from "./recovery.js";
+//# sourceMappingURL=index.js.map

package/node_modules/@codebridge/session-coordinator/dist/lease.d.ts

@@ -0,0 +1,14 @@
+import type { Run, SqliteEventStore } from "@codebridge/work-items";
+export declare class SessionLeaseService {
+    private readonly store;
+    private readonly now;
+    constructor(store: SqliteEventStore, options?: {
+        now?: () => Date;
+    });
+    claim(runId: string, owner: string): Run | null;
+    renew(runId: string, owner: string): Run | null;
+    /** 同一 owner 在仍执行该 Run 时，把已过期的租约重新续回来。 */
+    reclaimOwn(runId: string, owner: string): Run | null;
+    listExpired(limit?: number): Run[];
+}
+//# sourceMappingURL=lease.d.ts.map

package/node_modules/@codebridge/session-coordinator/dist/lease.js

@@ -0,0 +1,26 @@
+const LEASE_MS = 60_000;
+export class SessionLeaseService {
+    store;
+    now;
+    constructor(store, options = {}) {
+        this.store = store;
+        this.now = options.now ?? (() => new Date());
+    }
+    claim(runId, owner) {
+        const now = this.now();
+        return this.store.claimRun(runId, owner, now.toISOString(), new Date(now.getTime() + LEASE_MS).toISOString());
+    }
+    renew(runId, owner) {
+        const now = this.now();
+        return this.store.renewRunLease(runId, owner, now.toISOString(), new Date(now.getTime() + LEASE_MS).toISOString());
+    }
+    /** 同一 owner 在仍执行该 Run 时，把已过期的租约重新续回来。 */
+    reclaimOwn(runId, owner) {
+        const now = this.now();
+        return this.store.reclaimRunLease(runId, owner, new Date(now.getTime() + LEASE_MS).toISOString());
+    }
+    listExpired(limit = 100) {
+        return this.store.listExpiredRunningRuns(this.now().toISOString(), limit);
+    }
+}
+//# sourceMappingURL=lease.js.map

package/node_modules/@codebridge/session-coordinator/dist/queued-claim.d.ts

@@ -0,0 +1,20 @@
+import type { Run, SessionRuntime, SqliteEventStore } from "@codebridge/work-items";
+import type { SessionCoordinator } from "./coordinator.js";
+/** 从未启动的 queued Run，超过此时长不再自动领取，改为暂停等人 `/c`。 */
+export declare const QUEUED_RUN_FRESHNESS_MS: number;
+export declare function classifyQueuedRun(input: {
+    run: Run;
+    runtime: SessionRuntime | undefined;
+    nowMs: number;
+    hasStarted: boolean;
+}): "execute" | "stale" | "skip";
+export declare function reclaimQueuedRuns(input: {
+    store: SqliteEventStore;
+    coordinator: SessionCoordinator;
+    execute: (runId: string) => void;
+    now?: () => Date;
+}): {
+    executed: string[];
+    paused: string[];
+};
+//# sourceMappingURL=queued-claim.d.ts.map

package/node_modules/@codebridge/session-coordinator/dist/queued-claim.js

@@ -0,0 +1,45 @@
+/** 从未启动的 queued Run，超过此时长不再自动领取，改为暂停等人 `/c`。 */
+export const QUEUED_RUN_FRESHNESS_MS = 15 * 60_000;
+export function classifyQueuedRun(input) {
+    if (input.run.status !== "queued")
+        return "skip";
+    if (input.hasStarted)
+        return "skip";
+    if (!input.run.sessionId)
+        return "execute";
+    if (input.runtime?.queueState === "paused")
+        return "skip";
+    const createdMs = Date.parse(input.run.createdAt);
+    if (!Number.isFinite(createdMs) || input.nowMs - createdMs > QUEUED_RUN_FRESHNESS_MS) {
+        return "stale";
+    }
+    return "execute";
+}
+export function reclaimQueuedRuns(input) {
+    const nowMs = (input.now ?? (() => new Date()))().getTime();
+    const executed = [];
+    const paused = [];
+    for (const run of input.store.listRunsByStatus(["queued"])) {
+        const runtime = run.sessionId
+            ? input.store.getSessionRuntime(run.sessionId)
+            : undefined;
+        const hasStarted = input.store
+            .listEvents(run.workItemId)
+            .some((event) => event.runId === run.id && event.type === "RUN_STARTED");
+        const action = classifyQueuedRun({ run, runtime, nowMs, hasStarted });
+        if (action === "stale" && run.sessionId) {
+            input.coordinator.pauseQueue({
+                sessionId: run.sessionId,
+                reason: "stale",
+            });
+            paused.push(run.id);
+            continue;
+        }
+        if (action === "execute") {
+            input.execute(run.id);
+            executed.push(run.id);
+        }
+    }
+    return { executed, paused };
+}
+//# sourceMappingURL=queued-claim.js.map

package/node_modules/@codebridge/session-coordinator/dist/recovery.d.ts

@@ -0,0 +1,31 @@
+import type { SqliteEventStore } from "@codebridge/work-items";
+import { SessionCoordinator } from "./coordinator.js";
+import { SessionLeaseService } from "./lease.js";
+export type RecoveryAction = "repaired_succeeded" | "repaired_failed" | "repaired_cancelled" | "repaired_interrupted" | "interrupted" | "reclaimed_own";
+export interface OwnLiveRunOptions {
+    owner: string;
+    isExecuting: (runId: string) => boolean;
+}
+export declare class SessionRecoveryService {
+    private readonly store;
+    private readonly coordinator;
+    private readonly leases;
+    private readonly now;
+    private readonly ownLiveRun?;
+    constructor(store: SqliteEventStore, coordinator: SessionCoordinator, leases: SessionLeaseService, now?: () => Date, ownLiveRun?: OwnLiveRunOptions | undefined);
+    scanExpired(): Array<{
+        runId: string;
+        action: RecoveryAction;
+    }>;
+    scanCancellationDeadlines(): Array<{
+        runId: string;
+        action: "interrupted";
+    }>;
+    /**
+     * 本进程仍在执行该 Run（心跳/事件写入被事件循环长阻塞错过了续租窗口）时，
+     * 把 Run 租约和 provider-session 租约都续回来，而不是自我中断这个还活着的 Run。
+     */
+    private tryReclaimOwn;
+    private repairFromEvidence;
+}
+//# sourceMappingURL=recovery.d.ts.map

package/node_modules/@codebridge/session-coordinator/dist/recovery.js

@@ -0,0 +1,114 @@
+/** provider-session 租约时长，需与 run-executor 的 PROVIDER_LEASE_MS 保持一致。 */
+const PROVIDER_LEASE_MS = 60_000;
+export class SessionRecoveryService {
+    store;
+    coordinator;
+    leases;
+    now;
+    ownLiveRun;
+    constructor(store, coordinator, leases, now = () => new Date(), ownLiveRun) {
+        this.store = store;
+        this.coordinator = coordinator;
+        this.leases = leases;
+        this.now = now;
+        this.ownLiveRun = ownLiveRun;
+    }
+    scanExpired() {
+        return this.leases.listExpired().map((run) => {
+            const terminal = this.store.findTerminalEventForRun(run.id);
+            if (terminal)
+                return this.repairFromEvidence(run, terminal);
+            if (this.ownLiveRun
+                && run.leaseOwner === this.ownLiveRun.owner
+                && this.ownLiveRun.isExecuting(run.id)) {
+                const reclaimed = this.tryReclaimOwn(run);
+                if (reclaimed)
+                    return reclaimed;
+            }
+            if (!run.sessionId) {
+                throw new Error(`Expired leased Run has no Session: ${run.id}`);
+            }
+            this.coordinator.finishRun({
+                sessionId: run.sessionId,
+                runId: run.id,
+                status: "interrupted",
+                reason: run.replaySafety === "outcome_unknown"
+                    ? "lease_expired_unknown_outcome"
+                    : "lease_expired",
+            });
+            return { runId: run.id, action: "interrupted" };
+        });
+    }
+    scanCancellationDeadlines() {
+        return this.store
+            .listCancellationDeadlineRuns(this.now().toISOString(), 100)
+            .map((run) => {
+            if (!run.sessionId) {
+                throw new Error(`Cancelling Run has no Session: ${run.id}`);
+            }
+            this.coordinator.finishRun({
+                sessionId: run.sessionId,
+                runId: run.id,
+                status: "interrupted",
+                reason: "cancellation_deadline_exceeded",
+            });
+            return { runId: run.id, action: "interrupted" };
+        });
+    }
+    /**
+     * 本进程仍在执行该 Run（心跳/事件写入被事件循环长阻塞错过了续租窗口）时，
+     * 把 Run 租约和 provider-session 租约都续回来，而不是自我中断这个还活着的 Run。
+     */
+    tryReclaimOwn(run) {
+        const owner = this.ownLiveRun.owner;
+        // 先确认 provider session 还在自己手里：卡顿期间若已被别的 Run 接管，就不该续命，走原有中断。
+        if (run.providerSessionId
+            && run.agentId
+            && !this.store.renewProviderSession({
+                agentId: run.agentId,
+                providerSessionId: run.providerSessionId,
+                runId: run.id,
+                expiresAt: new Date(this.now().getTime() + PROVIDER_LEASE_MS).toISOString(),
+            })) {
+            return undefined;
+        }
+        const reclaimed = this.leases.reclaimOwn(run.id, owner);
+        if (!reclaimed)
+            return undefined;
+        const overdueMs = run.leaseExpiresAt
+            ? this.now().getTime() - new Date(run.leaseExpiresAt).getTime()
+            : 0;
+        console.warn(`${new Date().toISOString()} reclaimed_own_lease runId=${run.id} overdueMs=${overdueMs}`);
+        return { runId: run.id, action: "reclaimed_own" };
+    }
+    repairFromEvidence(run, event) {
+        if (!run.sessionId) {
+            throw new Error(`Terminal Run has no Session: ${run.id}`);
+        }
+        const status = terminalStatus(event.type);
+        this.coordinator.repairRunFromTerminalEvidence({
+            sessionId: run.sessionId,
+            runId: run.id,
+            status,
+        });
+        return {
+            runId: run.id,
+            action: `repaired_${status}`,
+        };
+    }
+}
+function terminalStatus(type) {
+    switch (type) {
+        case "RUN_SUCCEEDED":
+            return "succeeded";
+        case "RUN_FAILED":
+            return "failed";
+        case "RUN_CANCELLED":
+            return "cancelled";
+        case "RUN_INTERRUPTED":
+            return "interrupted";
+        default:
+            throw new Error(`Event is not terminal: ${type}`);
+    }
+}
+//# sourceMappingURL=recovery.js.map

package/node_modules/@codebridge/session-coordinator/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@codebridge/session-coordinator",
+  "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": {
+    "@codebridge/work-items": "0.1.0"
+  }
+}