@cursor/july 0.1.9 → 0.1.11

package/dist/internal/storage-coordinator.js

@@ -24,6 +24,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { resolveStoragePolicy, storageKeys, } from "../storage.js";
+import { isCursorHostedStorage } from "../storage-backends/cursor-hosted.js";
 import { describeError } from "./describe-error.js";
 import { isReminderRecord } from "./reminder-store.js";
 /** Event types that close a unit of work — flush point for turn-end batching. */
@@ -190,6 +191,13 @@ export class StorageCoordinator {
     get canBulkRestore() {
         return this.definition.list !== undefined;
     }
+    /**
+     * True when the authored sink is `cursorHostedStorage` (Bugbot via the
+     * control-plane proxy). `GET /v1/sessions` prefers this durable list.
+     */
+    get isCursorHosted() {
+        return isCursorHostedStorage(this.definition);
+    }
     /**
      * Saved session records for this agent (startup restore). Errors are
      * logged and read as "nothing saved" — a broken store must never block
@@ -203,6 +211,28 @@ export class StorageCoordinator {
                 .filter((record) => record != null);
         });
     }
+    /**
+     * Session records from the sink for the sessions API. Unlike
+     * {@link listSessions}, missing `list` or a thrown sink error **propagates**
+     * so the caller can fall back to the local session store.
+     */
+    listSessionsFromSink() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const list = this.definition.list;
+            if (list === undefined) {
+                throw new Error("storage sink has no list");
+            }
+            const entries = yield list(storageKeys.sessionPrefix(this.agentName), this.context("restore"));
+            if (!Array.isArray(entries)) {
+                throw new Error("storage list returned a non-array");
+            }
+            return entries
+                .map((entry) => entry.value)
+                .filter((record) => record != null &&
+                typeof record.sessionId === "string" &&
+                record.sessionId !== "");
+        });
+    }
     /**
      * Saved event stream for one session: chunk values concatenated in key
      * order (chunks are keyed by their first event's index, zero-padded, so

package/dist/internal/stream-progress.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-progress.d.ts","sourceRoot":"","sources":["../../src/internal/stream-progress.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,cAAc,CAqNjB"}
+{"version":3,"file":"stream-progress.d.ts","sourceRoot":"","sources":["../../src/internal/stream-progress.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAEhD,MAAM,WAAW,cAAc;IAC7B,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC,KAAK,IAAI,IAAI,CAAC;CACf;AAED,wBAAgB,oBAAoB,CAAC,OAAO,CAAC,EAAE;IAC7C,KAAK,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB,GAAG,cAAc,CA6NjB"}

package/dist/internal/stream-progress.js

@@ -21,7 +21,7 @@ export function createStreamProgress(options) {
     const elapsed = (since) => `${Date.now() - since}ms`;
     return {
         onEvent(event) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             switch (event.type) {
                 case "session.started": {
                     write(c.dim(`session ${event.sessionId}\n`));
@@ -35,12 +35,16 @@ export function createStreamProgress(options) {
                     }
                     break;
                 }
+                case "turn.queued": {
+                    write(c.dim(`  turn ${(_a = event.turnId) !== null && _a !== void 0 ? _a : "?"} queued (position ${event.data.position}, max ${event.data.maxRunningTurns} running)\n`));
+                    break;
+                }
                 case "turn.started": {
                     turnClock = Date.now();
                     if (event.turnId !== undefined) {
                         turnStartedAt.set(event.turnId, turnClock);
                     }
-                    write(c.dim(`  turn ${(_a = event.turnId) !== null && _a !== void 0 ? _a : "?"} started\n`));
+                    write(c.dim(`  turn ${(_b = event.turnId) !== null && _b !== void 0 ? _b : "?"} started\n`));
                     break;
                 }
                 case "message.received": {
@@ -131,11 +135,11 @@ export function createStreamProgress(options) {
                     const detail = event.data.description
                         ? ` — ${truncate(event.data.description, 60)}`
                         : "";
-                    write(`  ${c.magenta("task")} ${c.bold((_b = event.data.name) !== null && _b !== void 0 ? _b : "subagent")}${c.dim(detail)}\n`);
+                    write(`  ${c.magenta("task")} ${c.bold((_c = event.data.name) !== null && _c !== void 0 ? _c : "subagent")}${c.dim(detail)}\n`);
                     break;
                 }
                 case "subagent.completed": {
-                    write(`  ${c.magenta("✓")} ${c.bold((_c = event.data.name) !== null && _c !== void 0 ? _c : "subagent")} ${c.dim("done")}\n`);
+                    write(`  ${c.magenta("✓")} ${c.bold((_d = event.data.name) !== null && _d !== void 0 ? _d : "subagent")} ${c.dim("done")}\n`);
                     break;
                 }
                 case "turn.completed": {

package/dist/internal/turn-governor.d.ts

@@ -0,0 +1,54 @@
+/**
+ * FIFO admission of model turns under `concurrency.maxRunningTurns`
+ * (see {@link AgentConcurrencyOptions}). One governor per session engine:
+ * every turn acquires a slot before its SDK run starts and releases it when
+ * the run settles, so at most `maxRunningTurns` turns execute at once and
+ * the rest wait in arrival order instead of failing.
+ *
+ * Waiting is cancellable: the engine passes the turn's abort signal, so a
+ * follow-up that preempts a queued turn (or an explicit `interrupt()`)
+ * removes the waiter without ever running it.
+ */
+import type { AgentConcurrencyOptions } from "../types.js";
+export interface TurnPermit {
+    /** Return the slot. Idempotent; wakes the oldest waiter, if any. */
+    release(): void;
+}
+export interface AcquireTurnSlotArgs {
+    sessionId: string;
+    /** Abort waiting (preemption / interrupt). Ignored once a slot is held. */
+    signal?: AbortSignal;
+    /**
+     * Called synchronously when the turn must wait, with its 1-based
+     * position among waiting turns at enqueue time.
+     */
+    onQueued?: (position: number) => void;
+}
+export declare class TurnGovernor {
+    /** The configured ceiling, or undefined for unlimited. */
+    readonly maxRunningTurns: number | undefined;
+    private running;
+    private readonly waiters;
+    /** Sessions currently waiting for a slot (at most one turn per session). */
+    private readonly queuedSessions;
+    constructor(concurrency: AgentConcurrencyOptions | undefined);
+    /** True when a `maxRunningTurns` ceiling is configured. */
+    get limited(): boolean;
+    /** True while `sessionId` has a turn waiting for a slot. */
+    isQueued(sessionId: string): boolean;
+    /** Turns currently waiting for a slot. */
+    get queuedCount(): number;
+    /** Turns currently holding a slot. */
+    get runningCount(): number;
+    /**
+     * Acquire a turn slot. Resolves with a permit once a slot is free (FIFO
+     * behind earlier waiters), or with `undefined` when the abort signal
+     * fires while waiting — the turn must then settle as cancelled without
+     * running. Unlimited governors grant immediately.
+     */
+    acquire(args: AcquireTurnSlotArgs): Promise<TurnPermit | undefined>;
+    /** Take a slot and build its (idempotent) release handle. */
+    private grantSlot;
+    private wakeNextWaiter;
+}
+//# sourceMappingURL=turn-governor.d.ts.map

package/dist/internal/turn-governor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"turn-governor.d.ts","sourceRoot":"","sources":["../../src/internal/turn-governor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,aAAa,CAAC;AAE3D,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,WAAW,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AASD,qBAAa,YAAY;IACvB,0DAA0D;IAC1D,QAAQ,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7C,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoB;IAC5C,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqB;IAEpD,YAAY,WAAW,EAAE,uBAAuB,GAAG,SAAS,EAE3D;IAED,2DAA2D;IAC3D,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,4DAA4D;IAC5D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEnC;IAED,0CAA0C;IAC1C,IAAI,WAAW,IAAI,MAAM,CAExB;IAED,sCAAsC;IACtC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,mBAAmB,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAoClE;IAED,6DAA6D;IAC7D,OAAO,CAAC,SAAS;IAejB,OAAO,CAAC,cAAc;CAYvB"}

package/dist/internal/turn-governor.js

@@ -0,0 +1,111 @@
+/**
+ * FIFO admission of model turns under `concurrency.maxRunningTurns`
+ * (see {@link AgentConcurrencyOptions}). One governor per session engine:
+ * every turn acquires a slot before its SDK run starts and releases it when
+ * the run settles, so at most `maxRunningTurns` turns execute at once and
+ * the rest wait in arrival order instead of failing.
+ *
+ * Waiting is cancellable: the engine passes the turn's abort signal, so a
+ * follow-up that preempts a queued turn (or an explicit `interrupt()`)
+ * removes the waiter without ever running it.
+ */
+export class TurnGovernor {
+    constructor(concurrency) {
+        this.running = 0;
+        this.waiters = [];
+        /** Sessions currently waiting for a slot (at most one turn per session). */
+        this.queuedSessions = new Set();
+        this.maxRunningTurns = concurrency === null || concurrency === void 0 ? void 0 : concurrency.maxRunningTurns;
+    }
+    /** True when a `maxRunningTurns` ceiling is configured. */
+    get limited() {
+        return this.maxRunningTurns !== undefined;
+    }
+    /** True while `sessionId` has a turn waiting for a slot. */
+    isQueued(sessionId) {
+        return this.queuedSessions.has(sessionId);
+    }
+    /** Turns currently waiting for a slot. */
+    get queuedCount() {
+        return this.waiters.length;
+    }
+    /** Turns currently holding a slot. */
+    get runningCount() {
+        return this.running;
+    }
+    /**
+     * Acquire a turn slot. Resolves with a permit once a slot is free (FIFO
+     * behind earlier waiters), or with `undefined` when the abort signal
+     * fires while waiting — the turn must then settle as cancelled without
+     * running. Unlimited governors grant immediately.
+     */
+    acquire(args) {
+        var _a;
+        const limit = this.maxRunningTurns;
+        if (limit === undefined) {
+            return Promise.resolve(NO_OP_PERMIT);
+        }
+        if (this.running < limit && this.waiters.length === 0) {
+            return Promise.resolve(this.grantSlot());
+        }
+        // Saturated. A turn that is already preempted never enqueues.
+        if (((_a = args.signal) === null || _a === void 0 ? void 0 : _a.aborted) === true) {
+            return Promise.resolve(undefined);
+        }
+        return new Promise((resolve) => {
+            var _a, _b;
+            const waiter = {
+                sessionId: args.sessionId,
+                grant: (permit) => resolve(permit),
+                cancel: () => resolve(undefined),
+                cleanup: () => {
+                    var _a;
+                    this.queuedSessions.delete(args.sessionId);
+                    (_a = args.signal) === null || _a === void 0 ? void 0 : _a.removeEventListener("abort", onAbort);
+                },
+            };
+            const onAbort = () => {
+                const index = this.waiters.indexOf(waiter);
+                if (index === -1) {
+                    return;
+                }
+                this.waiters.splice(index, 1);
+                waiter.cleanup();
+                waiter.cancel();
+            };
+            this.waiters.push(waiter);
+            this.queuedSessions.add(args.sessionId);
+            (_a = args.signal) === null || _a === void 0 ? void 0 : _a.addEventListener("abort", onAbort, { once: true });
+            (_b = args.onQueued) === null || _b === void 0 ? void 0 : _b.call(args, this.waiters.length);
+        });
+    }
+    /** Take a slot and build its (idempotent) release handle. */
+    grantSlot() {
+        this.running += 1;
+        let released = false;
+        return {
+            release: () => {
+                if (released) {
+                    return;
+                }
+                released = true;
+                this.running -= 1;
+                this.wakeNextWaiter();
+            },
+        };
+    }
+    wakeNextWaiter() {
+        const limit = this.maxRunningTurns;
+        if (limit === undefined || this.running >= limit) {
+            return;
+        }
+        const waiter = this.waiters.shift();
+        if (waiter === undefined) {
+            return;
+        }
+        waiter.cleanup();
+        waiter.grant(this.grantSlot());
+    }
+}
+/** Permit handed out by unlimited governors. */
+const NO_OP_PERMIT = { release: () => { } };