pi-cursor-sdk 0.5.0 → 0.5.3

package/dist/cursor-session-store.js

@@ -1,9 +1,14 @@
 import { createHash, randomUUID } from "node:crypto";
+import { existsSync, lstatSync } from "node:fs";
 import { rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, join, toNamespacedPath } from "node:path";
+import { homedir, tmpdir } from "node:os";
+import { dirname, isAbsolute, join, relative, resolve, sep, toNamespacedPath } from "node:path";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
+import { guardCursorCustomStorePath, normalizeCursorCustomStoreRoot, prepareCursorCustomStoreRoot } from "./cursor-custom-store-path.js";
 let sdkOperationsForTests;
+const activeWorkspaceRoots = new Map();
+// ponytail: leases protect only extension-owned stores in this process. Other SDK
+// users/processes must stop before upgrade; a cross-process lock belongs in the SDK.
 export function hashCursorSessionStoreScope(scopeKey) {
     return createHash("sha256")
         .update("pi-cursor-sdk-session-store\0")
@@ -11,9 +16,8 @@ export function hashCursorSessionStoreScope(scopeKey) {
         .digest("hex")
         .slice(0, 32);
 }
-export function buildCursorSessionStateRoot(defaultStateRoot, scopeKey, persistent) {
-    const baseRoot = persistent ? defaultStateRoot : join(tmpdir(), `pi-cursor-sdk-${randomUUID()}`);
-    return join(baseRoot, "pi-sessions", hashCursorSessionStoreScope(scopeKey));
+export function buildCursorSessionStateRoot(defaultStateRoot, scopeKey) {
+    return join(defaultStateRoot, "pi-sessions", hashCursorSessionStoreScope(scopeKey));
 }
 async function getSdkOperations() {
     if (sdkOperationsForTests)
@@ -27,76 +31,262 @@ async function getSdkOperations() {
         openSqliteStore: (options) => SqliteLocalAgentStore.open(options),
     };
 }
-export async function getCursorSessionStoreIdentities(cwd, scopeKey, persistent) {
-    const defaultStateRoot = await (await getSdkOperations()).getDefaultStateRoot(cwd);
+function leaseWorkspaceRoot(key, ownership) {
+    ownership.users++;
+    let released = false;
     return {
-        defaultStore: { version: 1, stateRoot: defaultStateRoot },
-        sessionStore: {
-            version: 1,
-            stateRoot: buildCursorSessionStateRoot(defaultStateRoot, scopeKey, persistent),
+        root: ownership.root,
+        release: () => {
+            if (released)
+                return;
+            released = true;
+            if (--ownership.users === 0)
+                activeWorkspaceRoots.delete(key);
         },
     };
 }
+function workspaceLeaseKey(cwd, storeRoot) {
+    return JSON.stringify([cwd, storeRoot ?? null]);
+}
+function acquireWorkspaceRoot(cwd, storeRoot) {
+    const key = workspaceLeaseKey(cwd, storeRoot);
+    let ownership = activeWorkspaceRoots.get(key);
+    if (!ownership) {
+        ownership = {
+            // Publish ownership synchronously, before SDK loading or the public getter.
+            root: Promise.resolve().then(async () => {
+                if (storeRoot !== undefined) {
+                    const root = prepareCursorCustomStoreRoot(storeRoot);
+                    return join(root, createHash("sha256").update(resolve(cwd)).digest("hex").slice(0, 32));
+                }
+                const operations = await getSdkOperations();
+                assertSafeWorkspaceLayout(cwd);
+                const root = await operations.getDefaultStateRoot(cwd);
+                assertSafeStorePath(root, dirname(root), "local store");
+                return root;
+            }),
+            users: 0,
+        };
+        activeWorkspaceRoots.set(key, ownership);
+    }
+    return leaseWorkspaceRoot(key, ownership);
+}
+function retainWorkspaceRoot(cwd, workspaceRoot, storeRoot) {
+    const key = workspaceLeaseKey(cwd, storeRoot);
+    const ownership = activeWorkspaceRoots.get(key);
+    if (!ownership)
+        throw new Error("Cursor local workspace ownership is not active");
+    const lease = leaseWorkspaceRoot(key, ownership);
+    return {
+        ...lease,
+        root: lease.root.then((root) => {
+            if (root !== workspaceRoot)
+                throw new Error("Cursor local workspace ownership root mismatch");
+            return root;
+        }),
+    };
+}
+export async function withCursorSessionStoreIdentities(cwd, scopeKey, selectedRoot, use) {
+    const storeRoot = selectedRoot === undefined ? undefined : normalizeCursorCustomStoreRoot(selectedRoot);
+    const lease = acquireWorkspaceRoot(cwd, storeRoot);
+    try {
+        const workspaceRoot = await lease.root;
+        return await use({
+            workspaceRoot,
+            sessionStore: { version: 1, stateRoot: buildCursorSessionStateRoot(workspaceRoot, scopeKey) },
+            ...(storeRoot === undefined
+                ? { domain: "default", defaultStore: { version: 1, stateRoot: workspaceRoot } }
+                : { domain: "custom", storeRoot }),
+        });
+    }
+    finally {
+        lease.release();
+    }
+}
 export function cursorSessionStoreIdentitiesEqual(left, right) {
     return left.version === right.version && left.stateRoot === right.stateRoot;
 }
-async function openOwnedCursorSessionStore(cwd, identity, removalRoot) {
+function rejectedStorePath(stateRoot, base) {
+    // User-managed ancestors above the SDK prefix (or our temporary removal root)
+    // may be links/junctions. Owned components, including the base, may not.
+    let path = resolve(base);
+    const suffix = relative(path, resolve(stateRoot));
+    if (suffix === ".." || suffix.startsWith(`..${sep}`) || isAbsolute(suffix))
+        return stateRoot;
+    for (const component of ["", ...suffix.split(sep).filter(Boolean)]) {
+        path = join(path, component);
+        try {
+            if (!lstatSync(path).isDirectory())
+                return path;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+function assertSafeStorePath(stateRoot, base, label) {
+    const rejected = rejectedStorePath(stateRoot, base);
+    if (rejected)
+        throw new Error(`Cursor ${label} path contains a link or non-directory: ${rejected}`);
+}
+function workspaceHashes(cwd) {
+    const current = createHash("sha256").update(cwd).digest("hex");
+    try {
+        return { current, legacy: createHash("md5").update(cwd).digest("hex") };
+    }
+    catch (error) {
+        if (error.code === "ERR_OSSL_EVP_UNSUPPORTED" ||
+            (error instanceof Error && error.message === "Digest method not supported"))
+            return { current, legacy: undefined };
+        throw error;
+    }
+}
+function assertSafeWorkspaceLayout(cwd) {
+    // ponytail: SDK 1.0.37 has no public read-only root resolver; use one when exposed.
+    // This pure layout is contract-verified against its factory and public getter;
+    // guard it before that getter can rename MD5 history through an owned link.
+    const slug = cwd.replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+    const prefix = join(homedir(), ".cursor", "projects", slug, "sdk-agent-store");
+    const { current, legacy } = workspaceHashes(cwd);
+    for (const hash of [current, legacy]) {
+        if (hash)
+            assertSafeStorePath(join(prefix, hash), prefix, "local store");
+    }
+}
+function legacyWorkspaceRoot(cwd, defaultStateRoot) {
+    // The public getter owns migration and may return MD5 after a failed rename.
+    const { current, legacy } = workspaceHashes(cwd);
+    if (!legacy)
+        return undefined;
+    const prefix = dirname(defaultStateRoot);
+    if (defaultStateRoot !== join(prefix, current) && defaultStateRoot !== join(prefix, legacy))
+        return undefined;
+    return join(prefix, legacy);
+}
+export async function resolveCursorSessionStoreIdentity(options) {
+    const { cwd, scopeKey, identities, agentId } = options;
+    if (identities.domain === "custom") {
+        if (!options.recordedIdentity || !cursorSessionStoreIdentitiesEqual(options.recordedIdentity, identities.sessionStore))
+            return undefined;
+        // Cleanup admits each candidate before cached-store reuse, which skips the open-time guard.
+        assertSafeStorePath(identities.sessionStore.stateRoot, dirname(identities.workspaceRoot), "local store");
+        guardCursorCustomStorePath(dirname(identities.workspaceRoot), identities.sessionStore.stateRoot).verify();
+        return identities.sessionStore;
+    }
+    const legacyRoot = legacyWorkspaceRoot(cwd, identities.defaultStore.stateRoot);
+    const legacyDefault = legacyRoot ? { version: 1, stateRoot: legacyRoot } : undefined;
+    // Version-1 handles predate recorded identities and used the default workspace
+    // store. If both roots survive, that old store still owns their data.
+    const recorded = options.recordedIdentity ?? legacyDefault ?? identities.defaultStore;
+    const base = dirname(identities.defaultStore.stateRoot);
+    const current = [identities.defaultStore, identities.sessionStore];
+    const exact = current.find((identity) => cursorSessionStoreIdentitiesEqual(identity, recorded));
+    if (exact) {
+        assertSafeStorePath(exact.stateRoot, base, "local store");
+        return exact;
+    }
+    if (!legacyRoot)
+        return undefined;
+    const legacySession = { version: 1, stateRoot: buildCursorSessionStateRoot(legacyRoot, scopeKey) };
+    const legacy = [legacyDefault, legacySession].find((identity) => identity && cursorSessionStoreIdentitiesEqual(identity, recorded));
+    if (!legacy)
+        return undefined;
+    assertSafeStorePath(legacy.stateRoot, base, "local store");
+    if (existsSync(legacyRoot))
+        return legacy; // No merge or silent owner switch.
+    const migrated = legacy === legacyDefault ? identities.defaultStore : identities.sessionStore;
+    assertSafeStorePath(migrated.stateRoot, base, "local store");
+    if (!existsSync(migrated.stateRoot))
+        return undefined;
+    // A missing legacy path alone is not migration proof. The exact cwd/scope
+    // destination must independently contain this recorded agent with this cwd.
+    const opened = await openCursorSessionStore(cwd, migrated, identities.defaultStore.stateRoot);
+    try {
+        const agent = await opened.store.agents.get({ agentId });
+        return agent?.cwd === cwd ? migrated : undefined;
+    }
+    finally {
+        await opened.dispose();
+    }
+}
+async function openOwnedCursorSessionStore(cwd, identity, options) {
     const openedIdentity = Object.freeze({ ...identity });
+    const lease = "workspaceRoot" in options ? retainWorkspaceRoot(cwd, options.workspaceRoot, options.storeRoot) : undefined;
+    const removalRoot = "removalRoot" in options ? options.removalRoot : undefined;
+    const removeTemporaryStore = async () => {
+        if (removalRoot) {
+            assertSafeStorePath(openedIdentity.stateRoot, removalRoot, "temporary store removal");
+            await rm(removalRoot, { recursive: true, force: true });
+        }
+    };
     let store;
     try {
-        store = await (await getSdkOperations()).openSqliteStore({
+        await lease?.root;
+        const base = "workspaceRoot" in options ? dirname(options.workspaceRoot) : options.removalRoot;
+        assertSafeStorePath(openedIdentity.stateRoot, base, "local store");
+        const guard = "workspaceRoot" in options && options.storeRoot !== undefined
+            ? guardCursorCustomStorePath(base, openedIdentity.stateRoot) : undefined;
+        const operations = await getSdkOperations();
+        guard?.verify();
+        store = await operations.openSqliteStore({
             workspaceRef: cwd,
             stateRoot: toNamespacedPath(openedIdentity.stateRoot),
         });
+        guard?.verify();
     }
     catch (error) {
-        if (removalRoot)
-            await rm(removalRoot, { recursive: true, force: true }).catch(() => undefined);
+        await store?.dispose().catch(() => undefined);
+        lease?.release();
+        await removeTemporaryStore().catch(() => undefined);
         throw error;
     }
+    const openedStore = store;
     return {
         identity: openedIdentity,
-        store,
+        store: openedStore,
         dispose: async () => {
             try {
-                await store.dispose();
+                await openedStore.dispose();
             }
             finally {
-                if (removalRoot)
-                    await rm(removalRoot, { recursive: true, force: true });
+                lease?.release();
+                await removeTemporaryStore();
             }
         },
     };
 }
-export function openCursorSessionStore(cwd, identity) {
-    return openOwnedCursorSessionStore(cwd, identity);
+export function openCursorSessionStore(cwd, identity, workspaceRoot, storeRoot) {
+    return openOwnedCursorSessionStore(cwd, identity, { workspaceRoot, storeRoot });
 }
 export async function openCursorSessionStoreForScope(options) {
-    const identities = await getCursorSessionStoreIdentities(options.cwd, options.scopeKey, options.persistent);
-    const requestedResumeIdentity = options.hasResumeHandle
-        ? options.resumeIdentity ?? (options.persistent ? identities.defaultStore : undefined)
-        : undefined;
-    const resumableIdentities = options.persistent
-        ? [identities.defaultStore, identities.sessionStore]
-        : [identities.sessionStore];
-    const resumeIdentity = requestedResumeIdentity && resumableIdentities
-        .find((identity) => cursorSessionStoreIdentitiesEqual(identity, requestedResumeIdentity));
-    let resumeAttemptAllowed = options.hasResumeHandle && resumeIdentity !== undefined;
-    let resumeFallback = options.persistent && options.hasResumeHandle && !resumeIdentity;
-    const selectedIdentity = resumeIdentity ?? identities.sessionStore;
-    const removalRoot = options.persistent ? undefined : dirname(dirname(identities.sessionStore.stateRoot));
-    let sessionStore;
-    try {
-        sessionStore = await openOwnedCursorSessionStore(options.cwd, selectedIdentity, removalRoot);
-    }
-    catch (error) {
-        if (!resumeIdentity || cursorSessionStoreIdentitiesEqual(resumeIdentity, identities.sessionStore))
-            throw error;
-        resumeAttemptAllowed = false;
-        resumeFallback = true;
-        sessionStore = await openOwnedCursorSessionStore(options.cwd, identities.sessionStore);
+    if (!options.persistent) {
+        const removalRoot = join(tmpdir(), `pi-cursor-sdk-${randomUUID()}`);
+        const identity = { version: 1, stateRoot: buildCursorSessionStateRoot(removalRoot, options.scopeKey) };
+        const sessionStore = await openOwnedCursorSessionStore(options.cwd, identity, { removalRoot });
+        return { persistent: false, sessionStore, identities: { sessionStore: identity }, resumeAttemptAllowed: false, resumeFallback: false };
     }
-    return { sessionStore, identities, resumeAttemptAllowed, resumeFallback };
+    return withCursorSessionStoreIdentities(options.cwd, options.scopeKey, options.storeRoot, async (identities) => {
+        const resumeIdentity = options.resume ? await resolveCursorSessionStoreIdentity({
+            cwd: options.cwd, scopeKey: options.scopeKey, identities,
+            recordedIdentity: options.resume.identity, agentId: options.resume.agentId,
+        }).catch(() => undefined) : undefined; // Unreadable resume storage falls back; fresh-store failures still propagate.
+        let resumeAttemptAllowed = resumeIdentity !== undefined;
+        let resumeFallback = options.resume !== undefined && !resumeIdentity;
+        const selectedIdentity = resumeIdentity ?? identities.sessionStore;
+        let sessionStore;
+        try {
+            sessionStore = await openCursorSessionStore(options.cwd, selectedIdentity, identities.workspaceRoot, identities.storeRoot);
+        }
+        catch (error) {
+            if (!resumeIdentity || cursorSessionStoreIdentitiesEqual(resumeIdentity, identities.sessionStore))
+                throw error;
+            resumeAttemptAllowed = false;
+            resumeFallback = true;
+            sessionStore = await openCursorSessionStore(options.cwd, identities.sessionStore, identities.workspaceRoot, identities.storeRoot);
+        }
+        return { persistent: true, sessionStore, identities, resumeAttemptAllowed, resumeFallback };
+    });
 }
 export const __testUtils = {
     setSdkOperations(operations) {

package/dist/cursor-state.js

@@ -1,8 +1,10 @@
-import { buildCursorToolManifestText, CURSOR_TOOL_MANIFEST_ENV, resolveCursorToolManifestEnabled, } from "./cursor-tool-manifest.js";
+import { CURSOR_HOST_TOOL_MANIFEST_SUMMARY, CURSOR_TOOL_MANIFEST_ENV, resolveCursorToolManifestEnabled, } from "./cursor-tool-manifest.js";
 import { runCursorSessionAgentCleanupCommand } from "./cursor-session-agent-cleanup.js";
 import { CURSOR_HTTP1_ENTRY_TYPE, getStoredCursorHttp1Enabled, isCursorHttp1EntryData, setCursorHttp1GlobalPreferenceAuthoritative, setStoredCursorHttp1Enabled, } from "./cursor-http1.js";
-import { buildCursorPiToolBridgeSnapshot, CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-snapshot.js";
+import { buildCursorPiToolBridgeSnapshot, CURSOR_PI_TOOL_BRIDGE_ENV, resolveCursorPiToolBridgeBuiltinsEnabled, resolveCursorPiToolBridgeEnabled, } from "./cursor-pi-tool-bridge-snapshot.js";
+import { CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV } from "./cursor-pi-tool-bridge-diagnostics.js";
 import { CURSOR_SETTING_SOURCES_ENV, DEFAULT_CURSOR_SETTING_SOURCES, resolveCursorSettingSources, } from "./cursor-setting-sources.js";
+import { parseEnvBoolean } from "./cursor-env-boolean.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
 import { asRecord } from "./cursor-record-utils.js";
@@ -10,9 +12,10 @@ import { getCursorSessionScopeSnapshot, getCursorSessionScopeKey } from "./curso
 import { cursorSettingsScopeForContext, getCursorSessionSettings, registerCursorSessionSettings, resetCursorSessionSettingsForTests } from "./cursor-session-settings.js";
 import { refreshSessionCursorAgentConfig } from "./cursor-session-agent.js";
 import { getCursorModelMetadata } from "./model-discovery.js";
-import { cursorFastDefaultsFromConfig, getCursorSdkUserConfigPath, loadCursorSdkUserConfig, mergeCursorSdkConfigForUpdate, resolveCursorFastDefault, updateCursorSdkConfig, } from "./cursor-config.js";
+import { cursorFastDefaultsFromConfig, getCursorSdkUserConfigPath, loadCursorSdkUserConfig, mergeCursorSdkConfigForUpdate, resolveCursorFastDefault, resolveCursorLocalStoreRoot, updateCursorSdkConfig, } from "./cursor-config.js";
 import { CURSOR_RUNTIME_ENTRY_TYPE, formatCursorStatus, registerCursorCloudRuntimeControls, resetCursorRuntimeStateForTests, resolveCursorStatusRuntime, restoreCursorCliState, restoreSessionCursorRuntimeState, } from "./cursor-runtime-state.js";
 export { consumeCursorLocalForceOverride, getCursorCliConfig, getCursorSessionConfig, } from "./cursor-runtime-state.js";
+export const CURSOR_FOOTER_ENV = "PI_CURSOR_FOOTER";
 const FAST_ENTRY_TYPE = "cursor-fast-state";
 const MODE_ENTRY_TYPE = "cursor-mode-state";
 const DEFAULT_CURSOR_AGENT_MODE = "agent";
@@ -152,7 +155,7 @@ export function getCursorProviderAgentModeOrThrow(scopeKey) {
     return resolution.mode;
 }
 function updateCursorStatus(ctx, model = ctx.model) {
-    if (!model || !isCursorModel(model)) {
+    if (!model || !isCursorModel(model) || !parseEnvBoolean(process.env[CURSOR_FOOTER_ENV], true)) {
         ctx.ui.setStatus("cursor", undefined);
         return;
     }
@@ -272,7 +275,7 @@ export function formatCursorToolsDebugReport(pi, env = process.env) {
     const bridgeEnabled = resolveCursorPiToolBridgeEnabled(env);
     const manifestEnabled = resolveCursorToolManifestEnabled(env);
     const lines = [
-        "Cursor tool surfaces (current session):",
+        "Cursor tool surfaces (current registry snapshot; not a live run):",
         `${CURSOR_PI_TOOL_BRIDGE_ENV}: ${bridgeEnabled ? "enabled" : "disabled"}`,
         `${CURSOR_TOOL_MANIFEST_ENV}: ${manifestEnabled ? "enabled" : "disabled"}`,
         `${CURSOR_SETTING_SOURCES_ENV}: ${formatEffectiveCursorSettingSourcesLabel(env[CURSOR_SETTING_SOURCES_ENV])}`,
@@ -280,13 +283,23 @@ export function formatCursorToolsDebugReport(pi, env = process.env) {
     let bridgeSnapshot;
     if (bridgeEnabled) {
         try {
-            bridgeSnapshot = buildCursorPiToolBridgeSnapshot(pi);
+            bridgeSnapshot = buildCursorPiToolBridgeSnapshot(pi, {
+                exposeOverlappingBuiltins: resolveCursorPiToolBridgeBuiltinsEnabled(env),
+            });
         }
         catch {
             lines.push("Pi bridge snapshot: unavailable (extension tool APIs required).");
         }
     }
-    lines.push(buildCursorToolManifestText({ bridgeSnapshot, piBridgeEnabled: bridgeEnabled }));
+    lines.push(`Cursor host/MCP: ${CURSOR_HOST_TOOL_MANIFEST_SUMMARY}; configured MCP depends on Cursor settings.`, "Pi tool toggles affect pi tools/bridge exposure only; they do not disable Cursor host/configured MCP tools.");
+    if (!bridgeEnabled) {
+        lines.push("Pi bridge: disabled (PI_CURSOR_PI_TOOL_BRIDGE=0).");
+    }
+    else if (bridgeSnapshot) {
+        const names = bridgeSnapshot.tools.map((tool) => tool.mcpToolName).sort();
+        lines.push(`Pi bridge exposure eligibility: ${names.length ? names.join(", ") : "no eligible pi__* tools"}.`);
+    }
+    lines.push("This snapshot does not prove a run's endpoint attachment, MCP initialization, catalog fetch, or tool calls.", `For per-run observations, enable ${CURSOR_PI_TOOL_BRIDGE_DEBUG_ENV}=1 before the turn.`, "run_created/tools_exposed record exposure only; mcp_initialized records a validated notifications/initialized receipt; mcp_tools_list records catalog-handler output (toolCount), not client/model consumption or ongoing connection health.", "request_queued/resolved/rejected record actual bridge call handling; absent receipts do not diagnose why a client/model made no request.", "Not callable: cursor-replay-* IDs, pi history names, transcript labels.");
     return lines.join("\n");
 }
 function emitCursorToolsDebugReport(pi, ctx) {
@@ -362,7 +375,7 @@ export function registerCursorRuntimeControls(pi) {
         },
     });
     pi.registerCommand("cursor-tools", {
-        description: "Show live Cursor tool surfaces for this session (maintainer debug)",
+        description: "Show current-registry Cursor tool exposure eligibility (maintainer debug)",
         handler: async (_args, ctx) => {
             emitCursorToolsDebugReport(pi, ctx);
         },
@@ -413,7 +426,8 @@ export function registerCursorRuntimeControls(pi) {
     pi.registerCommand("cursor-local-resume-cleanup", {
         description: "Dry-run or delete recorded superseded local Cursor SDK agents",
         handler: async (args, ctx) => {
-            await runCursorSessionAgentCleanupCommand(pi, args, ctx);
+            const storeRoot = resolveCursorLocalStoreRoot({ user: loadCursorSdkUserConfig() }).value;
+            await runCursorSessionAgentCleanupCommand(pi, args, ctx, storeRoot);
         },
     });
     pi.registerCommand("cursor-refresh-config", {

package/dist/cursor-tool-manifest.js

@@ -1,7 +1,7 @@
 import { parseEnvBoolean } from "./cursor-env-boolean.js";
 export const CURSOR_TOOL_MANIFEST_ENV = "PI_CURSOR_TOOL_MANIFEST";
 /**
- * Representative @cursor/sdk@1.0.32 local-agent ToolType values; actual exposure can vary by run.
+ * Representative Cursor SDK local-agent ToolType values; actual exposure can vary by run.
  * See docs/cursor-native-tool-replay.md#sdk-tooltype-replay-matrix.
  */
 export const CURSOR_HOST_TOOL_MANIFEST_SUMMARY = "read/shell/search/edit/write and other host tools when Cursor exposes them";

package/dist/index.js

@@ -9,7 +9,7 @@ import { getCursorSessionScopeSnapshot, registerCursorSessionScope } from "./cur
 import { registerCursorSessionAgentLifecycle } from "./cursor-session-agent-lifecycle.js";
 import { registerCursorSessionAgentLineage } from "./cursor-session-agent-lineage.js";
 import { registerCursorSessionAgentResume } from "./cursor-session-agent-resume.js";
-import { resolveCursorApiKey } from "./cursor-api-key.js";
+import { normalizeCursorApiKey } from "./cursor-api-key.js";
 import { registerCursorFallbackIssueWarning } from "./cursor-fallback-warning.js";
 import { registerCursorAgentsContextDedup } from "./cursor-agents-context-registration.js";
 import { registerCursorOverflowNormalization } from "./cursor-provider-overflow.js";
@@ -22,7 +22,9 @@ export default async function (pi) {
     registerCursorSessionScope(pi);
     registerCursorUsageLedger(pi);
     registerCursorUsageCommand(pi);
+    let fallbackIssue;
     const registerCursorProvider = registerCursorProviderBinding(pi);
+    const setFallbackWarning = registerCursorFallbackIssueWarning(pi);
     registerCursorSessionAgentLineage(pi);
     registerCursorSessionAgentLifecycle(pi);
     registerCursorSessionAgentResume(pi);
@@ -36,39 +38,39 @@ export default async function (pi) {
     registerCursorPiToolBridge(pi);
     registerCursorAgentsContextDedup(pi);
     registerCursorOverflowNormalization(pi);
-    let fallbackIssue;
     const models = await discoverModels({
+        apiKey: normalizeCursorApiKey(process.env.CURSOR_API_KEY),
+        allowNetwork: false,
         onFallback: (issue) => {
             fallbackIssue = issue;
         },
     });
-    if (fallbackIssue) {
-        registerCursorFallbackIssueWarning(pi, fallbackIssue);
-    }
+    setFallbackWarning(fallbackIssue);
     pi.registerCommand("cursor-refresh-models", {
         description: "Refresh the live Cursor model catalog without restarting pi",
         handler: async (_args, ctx) => {
-            let refreshFallbackIssue;
-            const apiKey = resolveCursorApiKey(await ctx.modelRegistry.getApiKeyForProvider("cursor"));
-            const refreshedModels = await discoverModels({
-                apiKey,
-                forceRefresh: true,
-                onFallback: (issue) => {
-                    refreshFallbackIssue = issue;
-                },
-            });
-            registerCursorProvider(refreshedModels);
+            const result = await ctx.modelRegistry.refresh({ providers: ["cursor"], allowNetwork: true, force: true, signal: ctx.signal });
             if (!ctx.hasUI)
                 return;
-            if (refreshFallbackIssue) {
-                ctx.ui.notify(`Cursor model catalog refresh did not use a live catalog: ${refreshFallbackIssue.message}`, "warning");
+            if (result.aborted) {
+                ctx.ui.notify("Cursor model catalog refresh was cancelled.", "warning");
+            }
+            else if (result.errors.has("cursor")) {
+                ctx.ui.notify("Cursor model catalog refresh failed; the previous catalog was retained.", "warning");
+            }
+            else if (fallbackIssue) {
+                ctx.ui.notify(`Cursor model catalog refresh did not use a live catalog: ${fallbackIssue.message}`, "warning");
             }
             else {
-                ctx.ui.notify(`Cursor model catalog refreshed with ${refreshedModels.length} model${refreshedModels.length === 1 ? "" : "s"}.`, "info");
+                const count = ctx.modelRegistry.getAll().filter((model) => model.provider === "cursor").length;
+                ctx.ui.notify(`Cursor model catalog refreshed with ${count} model${count === 1 ? "" : "s"}.`, "info");
             }
         },
     });
-    registerCursorProvider(models);
+    registerCursorProvider(models, (issue) => {
+        fallbackIssue = issue;
+        setFallbackWarning(issue);
+    });
     // Register last so session_shutdown cleanup remains protected until other Cursor handlers finish.
     registerCursorSdkSessionProcessErrorGuard(pi);
 }