@cursor/bdk 0.2.9 → 0.2.10

package/dist/internal/session-links.js

@@ -11,47 +11,43 @@ export function sessionExternalLinks(record) {
     };
 }
 function slackUrl(record) {
-    var _a, _b, _c;
-    var _d, _e, _f, _g, _h, _j;
     const auth = record.auth;
     if (auth !== null && auth.authenticator === "slack") {
         const fromAuth = slackThreadPermalink({
-            channelId: (_d = (_a = auth.attributes) === null || _a === void 0 ? void 0 : _a.channel_id) !== null && _d !== void 0 ? _d : "",
-            threadTs: (_e = (_b = auth.attributes) === null || _b === void 0 ? void 0 : _b.thread_ts) !== null && _e !== void 0 ? _e : "",
-            teamId: (_c = auth.attributes) === null || _c === void 0 ? void 0 : _c.team_id,
+            channelId: auth.attributes?.channel_id ?? "",
+            threadTs: auth.attributes?.thread_ts ?? "",
+            teamId: auth.attributes?.team_id,
         });
         if (fromAuth !== null) {
             return fromAuth;
         }
     }
-    const fromTitle = ((_f = record.title) !== null && _f !== void 0 ? _f : "").trim().match(SLACK_TITLE);
+    const fromTitle = (record.title ?? "").trim().match(SLACK_TITLE);
     if (fromTitle !== null) {
-        return ((_g = slackThreadPermalink({
+        return (slackThreadPermalink({
             channelId: fromTitle[1],
             threadTs: fromTitle[2],
-        })) !== null && _g !== void 0 ? _g : undefined);
+        }) ?? undefined);
     }
-    const fromKey = ((_h = record.continuationKey) !== null && _h !== void 0 ? _h : "").trim().match(SLACK_CONTINUATION);
+    const fromKey = (record.continuationKey ?? "").trim().match(SLACK_CONTINUATION);
     if (fromKey === null) {
         return undefined;
     }
-    return ((_j = slackThreadPermalink({
+    return (slackThreadPermalink({
         channelId: fromKey[1],
         threadTs: fromKey[2],
-    })) !== null && _j !== void 0 ? _j : undefined);
+    }) ?? undefined);
 }
 function githubUrl(record) {
-    var _a;
-    var _b, _c;
-    const fromTitle = extractGithubPrRef((_b = record.title) !== null && _b !== void 0 ? _b : "");
+    const fromTitle = extractGithubPrRef(record.title ?? "");
     if (fromTitle !== undefined) {
         return fromTitle.url;
     }
-    const fromKey = parseGitHubPrContinuationKey((_c = record.continuationKey) !== null && _c !== void 0 ? _c : "");
+    const fromKey = parseGitHubPrContinuationKey(record.continuationKey ?? "");
     if (fromKey !== undefined) {
         return `https://github.com/${fromKey.owner}/${fromKey.repo}/pull/${fromKey.number}`;
     }
-    const repos = (_a = record.cloudOverride) === null || _a === void 0 ? void 0 : _a.repos;
+    const repos = record.cloudOverride?.repos;
     if (repos === undefined) {
         return undefined;
     }

package/dist/internal/session-run-log.js

@@ -5,15 +5,6 @@
  * turn start, then records completion or process failure. Persistence errors
  * never change the hosted execution response.
  */
-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 { cursorHostedFiles } from "../files-backends/cursor-hosted.js";
 import { agentSdkStorageKeys } from "../storage-protocol.js";
 import { resolveApiKeySync } from "./cursor/credentials.js";
@@ -28,10 +19,10 @@ export const SESSION_RUN_LOG_MAX_LINE_CHARS = 4096;
 /** Continuations are FIFO; keep a bounded history for the session UI. */
 export const SESSION_RUN_LOG_MAX_EXECUTIONS = 20;
 const MAX_ERROR_MESSAGE_CHARS = 4096;
-const MAX_ERROR_STACK_CHARS = 16384;
+const MAX_ERROR_STACK_CHARS = 16_384;
 const MAX_DOCUMENT_CHARS = 512 * 1024;
 /** Crash-handler flush must not block `process.exit`. */
-export const SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS = 2000;
+export const SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS = 2_000;
 let fatalFlush;
 /**
  * Install the process-level crash flush. One process has one active hosted
@@ -47,18 +38,16 @@ export function unregisterSessionRunFatalFlush() {
  * Await the registered crash flush, bounded so a hung store cannot prevent
  * `process.exit`. Soft-fail.
  */
-export function flushSessionRunFatal(error) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (fatalFlush === undefined) {
-            return;
-        }
-        yield Promise.race([
-            fatalFlush(error).catch(() => undefined),
-            new Promise(resolve => {
-                setTimeout(resolve, SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS);
-            }),
-        ]);
-    });
+export async function flushSessionRunFatal(error) {
+    if (fatalFlush === undefined) {
+        return;
+    }
+    await Promise.race([
+        fatalFlush(error).catch(() => undefined),
+        new Promise(resolve => {
+            setTimeout(resolve, SESSION_RUN_FATAL_FLUSH_TIMEOUT_MS);
+        }),
+    ]);
 }
 function boundedText(value, max) {
     return value.length > max ? `${value.slice(0, max)}…` : value;
@@ -72,7 +61,11 @@ function boundedOptionalText(value, max) {
 export function serializeSessionRunError(error) {
     if (error instanceof Error) {
         const stack = boundedOptionalText(error.stack, MAX_ERROR_STACK_CHARS);
-        return Object.assign({ name: boundedText(error.name.length > 0 ? error.name : "Error", 128), message: boundedText(error.message, MAX_ERROR_MESSAGE_CHARS) }, (stack === undefined ? {} : { stack }));
+        return {
+            name: boundedText(error.name.length > 0 ? error.name : "Error", 128),
+            message: boundedText(error.message, MAX_ERROR_MESSAGE_CHARS),
+            ...(stack === undefined ? {} : { stack }),
+        };
     }
     return {
         name: "Error",
@@ -97,8 +90,11 @@ function parseError(value) {
     const name = typeof value.name === "string" ? value.name : "";
     const message = typeof value.message === "string" ? value.message : "";
     const stack = typeof value.stack === "string" ? value.stack : undefined;
-    return Object.assign({ name,
-        message }, (stack === undefined ? {} : { stack }));
+    return {
+        name,
+        message,
+        ...(stack === undefined ? {} : { stack }),
+    };
 }
 function parseLogs(value) {
     if (!Array.isArray(value)) {
@@ -142,32 +138,62 @@ function parseExecution(value) {
     const abortReason = typeof value.abortReason === "string" ? value.abortReason : undefined;
     const message = typeof value.message === "string" ? value.message : undefined;
     const error = parseError(value.error);
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ executionId,
+    return {
+        executionId,
         writtenAt,
         sessionId,
         turnStatus,
-        durationMs }, (abortReason === undefined ? {} : { abortReason: abortReason })), (message === undefined ? {} : { message })), (error === undefined ? {} : { error })), (value.processDeath === true ? { processDeath: true } : {})), { logs: parseLogs(value.logs) });
+        durationMs,
+        ...(abortReason === undefined ? {} : { abortReason: abortReason }),
+        ...(message === undefined ? {} : { message }),
+        ...(error === undefined ? {} : { error }),
+        ...(value.processDeath === true ? { processDeath: true } : {}),
+        logs: parseLogs(value.logs),
+    };
 }
 export function lastFailureFromExecutions(executions) {
     const latest = executions.at(-1);
     if (latest === undefined || latest.turnStatus === "finished") {
         return undefined;
     }
-    return Object.assign(Object.assign(Object.assign(Object.assign({ executionId: latest.executionId, writtenAt: latest.writtenAt, turnStatus: latest.turnStatus }, (latest.abortReason === undefined ? {} : { abortReason: latest.abortReason })), (latest.message === undefined ? {} : { message: latest.message })), (latest.error === undefined ? {} : { error: latest.error })), (latest.processDeath === true ? { processDeath: true } : {}));
+    return {
+        executionId: latest.executionId,
+        writtenAt: latest.writtenAt,
+        turnStatus: latest.turnStatus,
+        ...(latest.abortReason === undefined ? {} : { abortReason: latest.abortReason }),
+        ...(latest.message === undefined ? {} : { message: latest.message }),
+        ...(latest.error === undefined ? {} : { error: latest.error }),
+        ...(latest.processDeath === true ? { processDeath: true } : {}),
+    };
 }
 function boundExecution(write) {
     const error = write.error === undefined
         ? undefined
-        : Object.assign({ name: boundedText(write.error.name, 128), message: boundedText(write.error.message, MAX_ERROR_MESSAGE_CHARS) }, (write.error.stack === undefined
+        : {
+            name: boundedText(write.error.name, 128),
+            message: boundedText(write.error.message, MAX_ERROR_MESSAGE_CHARS),
+            ...(write.error.stack === undefined
+                ? {}
+                : {
+                    stack: boundedText(write.error.stack, MAX_ERROR_STACK_CHARS),
+                }),
+        };
+    return {
+        executionId: write.executionId,
+        writtenAt: write.writtenAt,
+        sessionId: write.sessionId,
+        turnStatus: write.turnStatus,
+        durationMs: write.durationMs,
+        ...(write.abortReason === undefined ? {} : { abortReason: write.abortReason }),
+        ...(boundedOptionalText(write.message, MAX_ERROR_MESSAGE_CHARS) === undefined
             ? {}
             : {
-                stack: boundedText(write.error.stack, MAX_ERROR_STACK_CHARS),
-            }));
-    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ executionId: write.executionId, writtenAt: write.writtenAt, sessionId: write.sessionId, turnStatus: write.turnStatus, durationMs: write.durationMs }, (write.abortReason === undefined ? {} : { abortReason: write.abortReason })), (boundedOptionalText(write.message, MAX_ERROR_MESSAGE_CHARS) === undefined
-        ? {}
-        : {
-            message: boundedOptionalText(write.message, MAX_ERROR_MESSAGE_CHARS),
-        })), (error === undefined ? {} : { error })), (write.processDeath === true ? { processDeath: true } : {})), { logs: snapshotSessionRunLogs(write.logs) });
+                message: boundedOptionalText(write.message, MAX_ERROR_MESSAGE_CHARS),
+            }),
+        ...(error === undefined ? {} : { error }),
+        ...(write.processDeath === true ? { processDeath: true } : {}),
+        logs: snapshotSessionRunLogs(write.logs),
+    };
 }
 function upsertExecution(existing, next) {
     const executions = existing.filter(entry => entry.executionId !== next.executionId);
@@ -177,14 +203,22 @@ function upsertExecution(existing, next) {
 }
 function shrinkSessionDocument(document) {
     let executions = document.executions;
-    let next = Object.assign(Object.assign({}, document), { executions, lastFailure: lastFailureFromExecutions(executions) });
+    let next = {
+        ...document,
+        executions,
+        lastFailure: lastFailureFromExecutions(executions),
+    };
     let serialized = JSON.stringify(next);
     while (serialized.length > MAX_DOCUMENT_CHARS) {
         const oldestWithLogs = executions.findIndex(entry => entry.logs.length > 0);
         if (oldestWithLogs >= 0) {
             const entry = executions[oldestWithLogs];
             executions = executions.map((item, index) => index === oldestWithLogs
-                ? Object.assign(Object.assign({}, entry), { logs: entry.logs.slice(Math.ceil(entry.logs.length / 2)) }) : item);
+                ? {
+                    ...entry,
+                    logs: entry.logs.slice(Math.ceil(entry.logs.length / 2)),
+                }
+                : item);
         }
         else if (executions.length > 1) {
             executions = executions.slice(1);
@@ -192,7 +226,11 @@ function shrinkSessionDocument(document) {
         else {
             break;
         }
-        next = Object.assign(Object.assign({}, document), { executions, lastFailure: lastFailureFromExecutions(executions) });
+        next = {
+            ...document,
+            executions,
+            lastFailure: lastFailureFromExecutions(executions),
+        };
         serialized = JSON.stringify(next);
     }
     return next;
@@ -218,17 +256,21 @@ export function parseSessionRunLogDocument(value) {
     }
     executions.sort((a, b) => a.writtenAt.localeCompare(b.writtenAt));
     const lastFailure = lastFailureFromExecutions(executions);
-    return Object.assign(Object.assign({ v: SESSION_RUN_LOG_VERSION, sessionPublicId,
-        updatedAt }, (lastFailure === undefined ? {} : { lastFailure })), { executions });
+    return {
+        v: SESSION_RUN_LOG_VERSION,
+        sessionPublicId,
+        updatedAt,
+        ...(lastFailure === undefined ? {} : { lastFailure }),
+        executions,
+    };
 }
 export function createSessionRunLogStore(input) {
-    var _a;
     const { sink, agentName } = input;
-    const logger = (_a = input.logger) !== null && _a !== void 0 ? _a : (() => { });
+    const logger = input.logger ?? (() => { });
     let active;
-    const readDocument = (sessionPublicId) => __awaiter(this, void 0, void 0, function* () {
+    const readDocument = async (sessionPublicId) => {
         const key = agentSdkStorageKeys.sessionRun(agentName, sessionPublicId);
-        const body = yield sink.get(key);
+        const body = await sink.get(key);
         if (body === undefined) {
             return undefined;
         }
@@ -239,19 +281,18 @@ export function createSessionRunLogStore(input) {
             logger(`[bdk] session-run log: skip unreadable ${key} (${describeError(error)})`);
             return undefined;
         }
-    });
-    const persistWrite = (write) => __awaiter(this, void 0, void 0, function* () {
-        var _a;
+    };
+    const persistWrite = async (write) => {
         const fitted = boundExecution(write);
         let existing;
         try {
-            existing = yield readDocument(write.sessionPublicId);
+            existing = await readDocument(write.sessionPublicId);
         }
         catch (error) {
             logger(`[bdk] session-run log: persist failed for ${fitted.executionId} (${describeError(error)})`);
             return;
         }
-        const executions = upsertExecution((_a = existing === null || existing === void 0 ? void 0 : existing.executions) !== null && _a !== void 0 ? _a : [], fitted);
+        const executions = upsertExecution(existing?.executions ?? [], fitted);
         const document = shrinkSessionDocument({
             v: SESSION_RUN_LOG_VERSION,
             sessionPublicId: write.sessionPublicId,
@@ -260,7 +301,7 @@ export function createSessionRunLogStore(input) {
         });
         const key = agentSdkStorageKeys.sessionRun(agentName, document.sessionPublicId);
         try {
-            yield sink.put(key, new TextEncoder().encode(JSON.stringify(document)));
+            await sink.put(key, new TextEncoder().encode(JSON.stringify(document)));
         }
         catch (error) {
             logger(`[bdk] session-run log: persist failed for ${fitted.executionId} (${describeError(error)})`);
@@ -275,38 +316,44 @@ export function createSessionRunLogStore(input) {
             };
             return;
         }
-        if ((active === null || active === void 0 ? void 0 : active.executionId) === fitted.executionId) {
+        if (active?.executionId === fitted.executionId) {
             active = undefined;
         }
-    });
+    };
     return {
         persist: persistWrite,
-        read(sessionPublicId) {
-            return __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return yield readDocument(sessionPublicId);
-                }
-                catch (error) {
-                    logger(`[bdk] session-run log: read failed for ${sessionPublicId} (${describeError(error)})`);
-                    return undefined;
-                }
-            });
+        async read(sessionPublicId) {
+            try {
+                return await readDocument(sessionPublicId);
+            }
+            catch (error) {
+                logger(`[bdk] session-run log: read failed for ${sessionPublicId} (${describeError(error)})`);
+                return undefined;
+            }
         },
-        flushProcessDeath(reason, error) {
-            return __awaiter(this, void 0, void 0, function* () {
-                var _a;
-                var _b;
-                if (active === undefined) {
-                    return;
-                }
-                const current = active;
-                const serialized = error === undefined ? undefined : serializeSessionRunError(error);
-                const message = error instanceof Error
-                    ? error.message
-                    : error !== undefined
-                        ? String(error)
-                        : "process died during hosted execution";
-                yield persistWrite(Object.assign(Object.assign({ sessionPublicId: current.sessionPublicId, executionId: current.executionId, writtenAt: new Date().toISOString(), sessionId: current.sessionId, turnStatus: "error", durationMs: Math.max(0, Date.now() - current.startedAt), abortReason: reason, processDeath: true, message }, (serialized === undefined ? {} : { error: serialized })), { logs: snapshotSessionRunLogs((_b = (_a = input.snapshotLogs) === null || _a === void 0 ? void 0 : _a.call(input)) !== null && _b !== void 0 ? _b : []) }));
+        async flushProcessDeath(reason, error) {
+            if (active === undefined) {
+                return;
+            }
+            const current = active;
+            const serialized = error === undefined ? undefined : serializeSessionRunError(error);
+            const message = error instanceof Error
+                ? error.message
+                : error !== undefined
+                    ? String(error)
+                    : "process died during hosted execution";
+            await persistWrite({
+                sessionPublicId: current.sessionPublicId,
+                executionId: current.executionId,
+                writtenAt: new Date().toISOString(),
+                sessionId: current.sessionId,
+                turnStatus: "error",
+                durationMs: Math.max(0, Date.now() - current.startedAt),
+                abortReason: reason,
+                processDeath: true,
+                message,
+                ...(serialized === undefined ? {} : { error: serialized }),
+                logs: snapshotSessionRunLogs(input.snapshotLogs?.() ?? []),
             });
         },
     };
@@ -324,8 +371,13 @@ export function selectSessionRunLogStore(input) {
     if (hosting.kind !== "cursor-managed") {
         return undefined;
     }
-    return createSessionRunLogStore(Object.assign({ sink: cursorHostedFiles({
+    return createSessionRunLogStore({
+        sink: cursorHostedFiles({
             resolveStoreSourceId: () => hosting.resolveStoreIds().frameworkStoreSourceId,
-            resolveApiKey: () => { var _a; return (_a = resolveApiKeySync()) === null || _a === void 0 ? void 0 : _a.apiKey; },
-        }), agentName: input.project.name, logger: input.logger }, (input.snapshotLogs === undefined ? {} : { snapshotLogs: input.snapshotLogs })));
+            resolveApiKey: () => resolveApiKeySync()?.apiKey,
+        }),
+        agentName: input.project.name,
+        logger: input.logger,
+        ...(input.snapshotLogs === undefined ? {} : { snapshotLogs: input.snapshotLogs }),
+    });
 }