@cursor/bdk 0.2.8 → 0.2.10

package/dist/internal/session-store.js

@@ -12,15 +12,6 @@
  * conclude "no such session" rescans the directory first, listings pick up
  * new directories, and a cached record is re-read when its file changed.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { randomBytes } from "node:crypto";
 import { mkdir, readdir, readFile, rename, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -67,89 +58,79 @@ export class SessionStore {
      * share it rather than queueing another.
      */
     scan() {
-        var _a;
         if (this.scanning === undefined) {
             this.scanning = this.rescan().finally(() => {
                 this.scanning = undefined;
             });
-            (_a = this.hydrated) !== null && _a !== void 0 ? _a : (this.hydrated = this.scanning);
+            this.hydrated ??= this.scanning;
         }
         return this.scanning;
     }
-    rescan() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let entries;
-            try {
-                entries = yield readdir(this.sessionsDir);
+    async rescan() {
+        let entries;
+        try {
+            entries = await readdir(this.sessionsDir);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                // Unreadable for a reason other than absence: keep what we have
+                // rather than forgetting sessions we cannot currently list.
+                return;
             }
-            catch (error) {
-                if (error.code !== "ENOENT") {
-                    // Unreadable for a reason other than absence: keep what we have
-                    // rather than forgetting sessions we cannot currently list.
-                    return;
-                }
-                // No directory means no sessions; the cache must not outlive it.
-                entries = [];
+            // No directory means no sessions; the cache must not outlive it.
+            entries = [];
+        }
+        const present = new Set();
+        for (const sessionId of entries) {
+            if (!isSafeSessionId(sessionId)) {
+                continue;
             }
-            const present = new Set();
-            for (const sessionId of entries) {
-                if (!isSafeSessionId(sessionId)) {
-                    continue;
-                }
-                present.add(sessionId);
-                if (this.cache.has(sessionId)) {
-                    yield this.refreshIfChanged(sessionId);
-                    continue;
-                }
-                yield this.load(sessionId);
+            present.add(sessionId);
+            if (this.cache.has(sessionId)) {
+                await this.refreshIfChanged(sessionId);
+                continue;
             }
-            // The listing is a snapshot: a session saved since it was taken is not
-            // in `present` but is on disk, so ask the file rather than the listing.
-            for (const sessionId of [...this.cache.keys()]) {
-                if (!present.has(sessionId)) {
-                    yield this.refreshIfChanged(sessionId);
-                }
+            await this.load(sessionId);
+        }
+        // The listing is a snapshot: a session saved since it was taken is not
+        // in `present` but is on disk, so ask the file rather than the listing.
+        for (const sessionId of [...this.cache.keys()]) {
+            if (!present.has(sessionId)) {
+                await this.refreshIfChanged(sessionId);
             }
-        });
+        }
     }
-    ensureHydrated() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield ((_a = this.hydrated) !== null && _a !== void 0 ? _a : this.scan());
-        });
+    async ensureHydrated() {
+        await (this.hydrated ?? this.scan());
     }
-    readRecord(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!isSafeSessionId(sessionId)) {
-                return undefined;
-            }
-            try {
-                const raw = yield readFile(this.recordPath(sessionId), "utf8");
-                return JSON.parse(raw);
-            }
-            catch (_a) {
-                return undefined;
-            }
-        });
+    async readRecord(sessionId) {
+        if (!isSafeSessionId(sessionId)) {
+            return undefined;
+        }
+        try {
+            const raw = await readFile(this.recordPath(sessionId), "utf8");
+            return JSON.parse(raw);
+        }
+        catch {
+            return undefined;
+        }
     }
     /**
      * Identity of the file at `path`: inode plus mtime, so two renames within
      * one clock tick still read as different. Undefined when there is no
      * file; any other failure propagates.
      */
-    stampOf(path) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const info = yield stat(path);
-                return `${info.ino}:${info.mtimeMs}`;
-            }
-            catch (error) {
-                if (error.code === "ENOENT") {
-                    return undefined;
-                }
-                throw error;
+    async stampOf(path) {
+        try {
+            const info = await stat(path);
+            return `${info.ino}:${info.mtimeMs}`;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return undefined;
             }
-        });
+            throw error;
+        }
     }
     /**
      * Read a record from disk into the cache; returns it when present. The
@@ -157,45 +138,41 @@ export class SessionStore {
      * stale stamp, and the next lookup re-reads, rather than a fresh stamp on
      * stale bytes.
      */
-    load(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!isSafeSessionId(sessionId)) {
-                return undefined;
-            }
-            const stamp = yield this.stampOf(this.recordPath(sessionId)).catch(() => undefined);
-            if (stamp === undefined) {
-                return undefined;
-            }
-            const record = yield this.readRecord(sessionId);
-            if (record === undefined) {
-                return undefined;
-            }
-            this.remember(record, stamp);
-            return record;
-        });
+    async load(sessionId) {
+        if (!isSafeSessionId(sessionId)) {
+            return undefined;
+        }
+        const stamp = await this.stampOf(this.recordPath(sessionId)).catch(() => undefined);
+        if (stamp === undefined) {
+            return undefined;
+        }
+        const record = await this.readRecord(sessionId);
+        if (record === undefined) {
+            return undefined;
+        }
+        this.remember(record, stamp);
+        return record;
     }
-    refreshIfChanged(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let stamp;
-            try {
-                stamp = yield this.stampOf(this.recordPath(sessionId));
-            }
-            catch (_a) {
-                // Unreadable for a reason other than absence: keep what we have.
-                return;
-            }
-            if (stamp === undefined) {
-                // No file for a record we never stamped is our own `save` still
-                // writing it, not a deletion.
-                if (this.stamps.has(sessionId)) {
-                    this.evict(sessionId);
-                }
-                return;
-            }
-            if (stamp !== this.stamps.get(sessionId)) {
-                yield this.load(sessionId);
+    async refreshIfChanged(sessionId) {
+        let stamp;
+        try {
+            stamp = await this.stampOf(this.recordPath(sessionId));
+        }
+        catch {
+            // Unreadable for a reason other than absence: keep what we have.
+            return;
+        }
+        if (stamp === undefined) {
+            // No file for a record we never stamped is our own `save` still
+            // writing it, not a deletion.
+            if (this.stamps.has(sessionId)) {
+                this.evict(sessionId);
             }
-        });
+            return;
+        }
+        if (stamp !== this.stamps.get(sessionId)) {
+            await this.load(sessionId);
+        }
     }
     remember(record, stamp) {
         const previous = this.cache.get(record.sessionId);
@@ -214,7 +191,7 @@ export class SessionStore {
         const previous = this.cache.get(sessionId);
         this.cache.delete(sessionId);
         this.stamps.delete(sessionId);
-        if ((previous === null || previous === void 0 ? void 0 : previous.continuationKey) != null) {
+        if (previous?.continuationKey != null) {
             this.unindex(previous);
         }
     }
@@ -248,63 +225,55 @@ export class SessionStore {
             this.continuationIndex.set(this.continuationKeyOf(record.channelId, record.continuationKey), record.sessionId);
         }
     }
-    get(sessionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!isSafeSessionId(sessionId)) {
-                return undefined;
-            }
-            if (this.cache.has(sessionId)) {
-                yield this.refreshIfChanged(sessionId);
-                return this.cache.get(sessionId);
-            }
-            return this.load(sessionId);
-        });
+    async get(sessionId) {
+        if (!isSafeSessionId(sessionId)) {
+            return undefined;
+        }
+        if (this.cache.has(sessionId)) {
+            await this.refreshIfChanged(sessionId);
+            return this.cache.get(sessionId);
+        }
+        return this.load(sessionId);
     }
-    list() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.scan();
-            return [...this.cache.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-        });
+    async list() {
+        await this.scan();
+        return [...this.cache.values()].sort((a, b) => a.createdAt.localeCompare(b.createdAt));
     }
-    findByContinuation(channelId, key) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.ensureHydrated();
-            const indexKey = this.continuationKeyOf(channelId, key);
-            const lookup = () => __awaiter(this, void 0, void 0, function* () {
-                const sessionId = this.continuationIndex.get(indexKey);
-                if (sessionId === undefined) {
-                    return undefined;
-                }
-                const record = yield this.get(sessionId);
-                // `get` may have re-read the record and found its continuation moved,
-                // or evicted it; either way this hit is stale.
-                return (record === null || record === void 0 ? void 0 : record.continuationKey) === key ? record : undefined;
-            });
-            const found = yield lookup();
-            if (found !== undefined) {
-                return found;
+    async findByContinuation(channelId, key) {
+        await this.ensureHydrated();
+        const indexKey = this.continuationKeyOf(channelId, key);
+        const lookup = async () => {
+            const sessionId = this.continuationIndex.get(indexKey);
+            if (sessionId === undefined) {
+                return undefined;
             }
-            // A miss or a stale hit: another process may have created or re-keyed a
-            // session since the last scan. Rescan once and retry.
-            yield this.scan();
-            return lookup();
-        });
+            const record = await this.get(sessionId);
+            // `get` may have re-read the record and found its continuation moved,
+            // or evicted it; either way this hit is stale.
+            return record?.continuationKey === key ? record : undefined;
+        };
+        const found = await lookup();
+        if (found !== undefined) {
+            return found;
+        }
+        // A miss or a stale hit: another process may have created or re-keyed a
+        // session since the last scan. Rescan once and retry.
+        await this.scan();
+        return lookup();
     }
-    save(record) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.remember(record, undefined);
-            const dir = this.sessionDir(record.sessionId);
-            yield mkdir(dir, { recursive: true });
-            const finalPath = this.recordPath(record.sessionId);
-            const tmpPath = `${finalPath}.${randomBytes(4).toString("hex")}.tmp`;
-            yield writeFile(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
-            // Stamp the bytes we wrote, not whatever is at `finalPath` afterwards:
-            // rename keeps inode and mtime, and a peer landing right behind us must
-            // read as a change. Remember again so a concurrent read that loaded the
-            // peer's earlier file does not leave the cache pointing at it.
-            const stamp = yield this.stampOf(tmpPath);
-            yield rename(tmpPath, finalPath);
-            this.remember(record, stamp);
-        });
+    async save(record) {
+        this.remember(record, undefined);
+        const dir = this.sessionDir(record.sessionId);
+        await mkdir(dir, { recursive: true });
+        const finalPath = this.recordPath(record.sessionId);
+        const tmpPath = `${finalPath}.${randomBytes(4).toString("hex")}.tmp`;
+        await writeFile(tmpPath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+        // Stamp the bytes we wrote, not whatever is at `finalPath` afterwards:
+        // rename keeps inode and mtime, and a peer landing right behind us must
+        // read as a change. Remember again so a concurrent read that loaded the
+        // peer's earlier file does not leave the cache pointing at it.
+        const stamp = await this.stampOf(tmpPath);
+        await rename(tmpPath, finalPath);
+        this.remember(record, stamp);
     }
 }

package/dist/internal/sessions-client.js

@@ -3,126 +3,108 @@
  *
  * Customer-facing errors never include hosting URLs or infra jargon.
  */
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 import { sanitizeCustomerError } from "./logs-client.js";
 import { mergeRequestHeaders } from "./request-headers.js";
-export function listSessions(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return (yield listSessionsWithSource(args)).sessions;
-    });
+export async function listSessions(args) {
+    return (await listSessionsWithSource(args)).sessions;
 }
-export function listSessionsWithSource(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const baseUrl = args.baseUrl.replace(/\/$/, "");
-        const fetchImpl = (_a = args.fetchImpl) !== null && _a !== void 0 ? _a : fetch;
-        const query = args.latest === true ? "?latest=1" : "";
-        let resp;
-        try {
-            resp = yield fetchImpl(`${baseUrl}/v1/sessions${query}`, {
-                headers: mergeRequestHeaders(args.auth),
-            });
-        }
-        catch (error) {
-            throw new Error(sanitizeCustomerError(error instanceof Error ? error.message : "Could not list sessions."));
-        }
-        if (!resp.ok) {
-            throw new Error(`Could not list sessions (HTTP ${resp.status}).`);
-        }
-        const body = (yield resp.json());
-        const sessions = [];
-        if (Array.isArray(body.sessions)) {
-            for (const row of body.sessions) {
-                const parsed = parseSessionSummary(row);
-                if (parsed !== undefined) {
-                    sessions.push(parsed);
-                }
+export async function listSessionsWithSource(args) {
+    const baseUrl = args.baseUrl.replace(/\/$/, "");
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const query = args.latest === true ? "?latest=1" : "";
+    let resp;
+    try {
+        resp = await fetchImpl(`${baseUrl}/v1/sessions${query}`, {
+            headers: mergeRequestHeaders(args.auth),
+        });
+    }
+    catch (error) {
+        throw new Error(sanitizeCustomerError(error instanceof Error ? error.message : "Could not list sessions."));
+    }
+    if (!resp.ok) {
+        throw new Error(`Could not list sessions (HTTP ${resp.status}).`);
+    }
+    const body = (await resp.json());
+    const sessions = [];
+    if (Array.isArray(body.sessions)) {
+        for (const row of body.sessions) {
+            const parsed = parseSessionSummary(row);
+            if (parsed !== undefined) {
+                sessions.push(parsed);
             }
         }
-        const source = body.source === "cursor-hosted" || body.source === "local" ? body.source : undefined;
-        return source === undefined ? { sessions } : { sessions, source };
-    });
+    }
+    const source = body.source === "cursor-hosted" || body.source === "local" ? body.source : undefined;
+    return source === undefined ? { sessions } : { sessions, source };
 }
-export function fetchSessionEvents(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        var _c;
-        const baseUrl = args.baseUrl.replace(/\/$/, "");
-        const fetchImpl = (_c = args.fetchImpl) !== null && _c !== void 0 ? _c : fetch;
-        const path = `/v1/session/${encodeURIComponent(args.sessionId)}/events`;
-        try {
-            const jsonResp = yield fetchImpl(`${baseUrl}${path}?format=json`, {
-                headers: mergeRequestHeaders(args.auth),
-                signal: args.signal,
-            });
-            if (jsonResp.ok) {
-                const body = (yield jsonResp.json());
-                if (Array.isArray(body.events)) {
-                    return body.events;
-                }
-            }
-            else if (jsonResp.status === 404) {
-                throw new Error(`Session ${args.sessionId} not found.`);
-            }
-            else if (jsonResp.status === 403) {
-                throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
+export async function fetchSessionEvents(args) {
+    const baseUrl = args.baseUrl.replace(/\/$/, "");
+    const fetchImpl = args.fetchImpl ?? fetch;
+    const path = `/v1/session/${encodeURIComponent(args.sessionId)}/events`;
+    try {
+        const jsonResp = await fetchImpl(`${baseUrl}${path}?format=json`, {
+            headers: mergeRequestHeaders(args.auth),
+            signal: args.signal,
+        });
+        if (jsonResp.ok) {
+            const body = (await jsonResp.json());
+            if (Array.isArray(body.events)) {
+                return body.events;
             }
         }
-        catch (error) {
-            (_a = args.signal) === null || _a === void 0 ? void 0 : _a.throwIfAborted();
-            if (error instanceof Error && error.message.startsWith("Session ")) {
-                throw error;
-            }
-            // Fall through to NDJSON.
+        else if (jsonResp.status === 404) {
+            throw new Error(`Session ${args.sessionId} not found.`);
         }
-        try {
-            const resp = yield fetchImpl(`${baseUrl}${path}`, {
-                headers: mergeRequestHeaders(args.auth),
-                signal: args.signal,
-            });
-            if (resp.status === 404) {
-                throw new Error(`Session ${args.sessionId} not found.`);
-            }
-            if (resp.status === 403) {
-                throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
+        else if (jsonResp.status === 403) {
+            throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
+        }
+    }
+    catch (error) {
+        args.signal?.throwIfAborted();
+        if (error instanceof Error && error.message.startsWith("Session ")) {
+            throw error;
+        }
+        // Fall through to NDJSON.
+    }
+    try {
+        const resp = await fetchImpl(`${baseUrl}${path}`, {
+            headers: mergeRequestHeaders(args.auth),
+            signal: args.signal,
+        });
+        if (resp.status === 404) {
+            throw new Error(`Session ${args.sessionId} not found.`);
+        }
+        if (resp.status === 403) {
+            throw new Error(`Session ${args.sessionId} is not readable by this caller.`);
+        }
+        if (!resp.ok) {
+            throw new Error(`Could not fetch session events (HTTP ${resp.status}).`);
+        }
+        const text = await resp.text();
+        const events = [];
+        for (const line of text.split("\n")) {
+            if (line.trim() === "") {
+                continue;
             }
-            if (!resp.ok) {
-                throw new Error(`Could not fetch session events (HTTP ${resp.status}).`);
+            try {
+                events.push(JSON.parse(line));
             }
-            const text = yield resp.text();
-            const events = [];
-            for (const line of text.split("\n")) {
-                if (line.trim() === "") {
-                    continue;
-                }
-                try {
-                    events.push(JSON.parse(line));
-                }
-                catch (_d) {
-                    // skip malformed lines
-                }
+            catch {
+                // skip malformed lines
             }
-            return events;
         }
-        catch (error) {
-            (_b = args.signal) === null || _b === void 0 ? void 0 : _b.throwIfAborted();
-            if (error instanceof Error && error.message.startsWith("Session ")) {
-                throw error;
-            }
-            if (error instanceof Error && error.message.startsWith("Could not fetch")) {
-                throw new Error(sanitizeCustomerError(error.message));
-            }
-            throw new Error(sanitizeCustomerError(error instanceof Error ? error.message : "Could not fetch session events."));
+        return events;
+    }
+    catch (error) {
+        args.signal?.throwIfAborted();
+        if (error instanceof Error && error.message.startsWith("Session ")) {
+            throw error;
         }
-    });
+        if (error instanceof Error && error.message.startsWith("Could not fetch")) {
+            throw new Error(sanitizeCustomerError(error.message));
+        }
+        throw new Error(sanitizeCustomerError(error instanceof Error ? error.message : "Could not fetch session events."));
+    }
 }
 /** Lenient parse so partial stubs / older servers still list by sessionId. */
 function parseSessionSummary(value) {
@@ -168,16 +150,13 @@ export function pickPreviousSession(sessions) {
     return [...followable].sort((a, b) => b.updatedAt.localeCompare(a.updatedAt))[0];
 }
 /** Look up the most recently updated followable session id. */
-export function resolvePreviousSessionId(args) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const sessions = yield listSessions({
-            baseUrl: args.baseUrl,
-            auth: args.auth,
-            fetchImpl: args.fetchImpl,
-        });
-        return (_a = pickPreviousSession(sessions)) === null || _a === void 0 ? void 0 : _a.sessionId;
+export async function resolvePreviousSessionId(args) {
+    const sessions = await listSessions({
+        baseUrl: args.baseUrl,
+        auth: args.auth,
+        fetchImpl: args.fetchImpl,
     });
+    return pickPreviousSession(sessions)?.sessionId;
 }
 /** Human label for {@link SessionListSource} in CLI output. */
 export function formatSessionListSource(source) {
@@ -187,7 +166,7 @@ export function formatSessionListSource(source) {
 }
 /** Format a sessions table (id, channel, mode, turns, running, updated). */
 export function formatSessionsTable(sessions, options) {
-    const sourceLine = (options === null || options === void 0 ? void 0 : options.source) === undefined ? "" : `${formatSessionListSource(options.source)}\n`;
+    const sourceLine = options?.source === undefined ? "" : `${formatSessionListSource(options.source)}\n`;
     if (sessions.length === 0) {
         return `${sourceLine}No sessions.\n`;
     }
@@ -203,9 +182,9 @@ export function formatSessionsTable(sessions, options) {
     return `${sourceLine}${renderTable(header, rows)}\n`;
 }
 function renderTable(header, rows) {
-    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(row => { var _a; return ((_a = row[i]) !== null && _a !== void 0 ? _a : "").length; })));
+    const widths = header.map((h, i) => Math.max(h.length, ...rows.map(row => (row[i] ?? "").length)));
     const renderRow = (row) => row
-        .map((cell, i) => { var _a; return cell.padEnd((_a = widths[i]) !== null && _a !== void 0 ? _a : 0); })
+        .map((cell, i) => cell.padEnd(widths[i] ?? 0))
         .join("  ")
         .trimEnd();
     return [renderRow(header), ...rows.map(renderRow)].join("\n");