pi-cursor-sdk 0.2.0 → 0.3.6

package/dist/cursor-mcp-timeout-override.js

@@ -0,0 +1,116 @@
+const CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS = 60_000;
+const DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS = 3_600_000;
+const DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS = 10_000;
+const MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS = 1_000;
+const MAX_NODE_TIMER_DELAY_MS = 2_147_483_647;
+const CURSOR_MCP_TOOL_TIMEOUT_MS_ENV = "PI_CURSOR_MCP_TOOL_TIMEOUT_MS";
+const CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV = "PI_CURSOR_MCP_TOOL_TIMEOUT_SECONDS";
+const CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV = "PI_CURSOR_MCP_CONNECT_TIMEOUT_MS";
+const CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV = "PI_CURSOR_MCP_CONNECT_TIMEOUT_SECONDS";
+let originalSetTimeout;
+let installedToolTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+let installedConnectTimeoutMs = DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+function parsePositiveNumber(value) {
+    const trimmed = value?.trim();
+    if (!trimmed)
+        return undefined;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : undefined;
+}
+function normalizeOverrideTimeoutMs(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+    return Math.min(Math.max(Math.trunc(timeoutMs), CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS), MAX_NODE_TIMER_DELAY_MS);
+}
+export function resolveCursorMcpToolTimeoutMs(env = process.env) {
+    const explicitMs = parsePositiveNumber(env[CURSOR_MCP_TOOL_TIMEOUT_MS_ENV]);
+    if (explicitMs !== undefined)
+        return normalizeOverrideTimeoutMs(explicitMs);
+    const explicitSeconds = parsePositiveNumber(env[CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV]);
+    if (explicitSeconds !== undefined)
+        return normalizeOverrideTimeoutMs(explicitSeconds * 1000);
+    return DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+}
+function normalizeConnectTimeoutMs(timeoutMs) {
+    if (!Number.isFinite(timeoutMs) || timeoutMs <= 0)
+        return DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+    return Math.min(Math.max(Math.trunc(timeoutMs), MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS), CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS);
+}
+export function resolveCursorMcpConnectTimeoutMs(env = process.env) {
+    const explicitMs = parsePositiveNumber(env[CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV]);
+    if (explicitMs !== undefined)
+        return normalizeConnectTimeoutMs(explicitMs);
+    const explicitSeconds = parsePositiveNumber(env[CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV]);
+    if (explicitSeconds !== undefined)
+        return normalizeConnectTimeoutMs(explicitSeconds * 1000);
+    return DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+}
+function isCursorSdkMcpProtocolTimeoutStack(stack) {
+    if (!stack)
+        return false;
+    return (/(?:node_modules[/\\]@cursor[/\\]sdk|node_modules\/\@cursor\/sdk|@cursor\/sdk\/dist)/.test(stack) &&
+        /\b_setupTimeout\b|\bProtocol\._setupTimeout\b/.test(stack));
+}
+export function isCursorSdkMcpToolTimeoutStack(stack) {
+    if (!stack)
+        return false;
+    return (isCursorSdkMcpProtocolTimeoutStack(stack) &&
+        /\bcallTool\b|\bClient\.callTool\b|\bMcpSdkClient\.callTool\b/.test(stack));
+}
+export function isCursorSdkMcpConnectTimeoutStack(stack) {
+    if (!stack || !isCursorSdkMcpProtocolTimeoutStack(stack))
+        return false;
+    return /\bClient\.(?:connect|listTools)\b|\bMcpSdkClient\.getTools\b/.test(stack);
+}
+function isCursorSdkDefaultMcpTimeout(delay) {
+    return typeof delay === "number" && delay === CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS;
+}
+function patchedSetTimeout(handler, delay, ...args) {
+    const delegate = originalSetTimeout;
+    if (!delegate)
+        throw new Error("Cursor MCP timeout override installed without original setTimeout");
+    let nextDelay = delay;
+    if (isCursorSdkDefaultMcpTimeout(delay)) {
+        const stack = new Error().stack;
+        if (isCursorSdkMcpToolTimeoutStack(stack)) {
+            nextDelay = installedToolTimeoutMs;
+        }
+        else if (isCursorSdkMcpConnectTimeoutStack(stack)) {
+            nextDelay = installedConnectTimeoutMs;
+        }
+    }
+    return Reflect.apply(delegate, globalThis, [handler, nextDelay, ...args]);
+}
+export function installCursorMcpToolTimeoutOverride(options = {}) {
+    installedToolTimeoutMs = normalizeOverrideTimeoutMs(options.timeoutMs ?? resolveCursorMcpToolTimeoutMs(options.env));
+    installedConnectTimeoutMs = normalizeConnectTimeoutMs(options.connectTimeoutMs ?? resolveCursorMcpConnectTimeoutMs(options.env));
+    if (!originalSetTimeout) {
+        originalSetTimeout = globalThis.setTimeout;
+        globalThis.setTimeout = patchedSetTimeout;
+    }
+    return {
+        installed: true,
+        timeoutMs: installedToolTimeoutMs,
+        connectTimeoutMs: installedConnectTimeoutMs,
+        sdkDefaultTimeoutMs: CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
+    };
+}
+export function restoreCursorMcpToolTimeoutOverride() {
+    if (originalSetTimeout) {
+        globalThis.setTimeout = originalSetTimeout;
+        originalSetTimeout = undefined;
+    }
+    installedToolTimeoutMs = DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS;
+    installedConnectTimeoutMs = DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS;
+}
+export const cursorMcpToolTimeoutOverrideDefaults = {
+    cursorSdkDefaultTimeoutMs: CURSOR_SDK_MCP_DEFAULT_TIMEOUT_MS,
+    defaultOverrideTimeoutMs: DEFAULT_CURSOR_MCP_TOOL_TIMEOUT_MS,
+    defaultConnectTimeoutMs: DEFAULT_CURSOR_MCP_CONNECT_TIMEOUT_MS,
+    minConnectTimeoutMs: MIN_CURSOR_MCP_CONNECT_TIMEOUT_MS,
+    maxNodeTimerDelayMs: MAX_NODE_TIMER_DELAY_MS,
+    timeoutMsEnv: CURSOR_MCP_TOOL_TIMEOUT_MS_ENV,
+    timeoutSecondsEnv: CURSOR_MCP_TOOL_TIMEOUT_SECONDS_ENV,
+    connectTimeoutMsEnv: CURSOR_MCP_CONNECT_TIMEOUT_MS_ENV,
+    connectTimeoutSecondsEnv: CURSOR_MCP_CONNECT_TIMEOUT_SECONDS_ENV,
+};

package/dist/cursor-model-lifecycle.js

@@ -0,0 +1,32 @@
+function normalizeLifecycleHandlers(handlerOrHandlers) {
+    return typeof handlerOrHandlers === "function" ? { sync: handlerOrHandlers } : handlerOrHandlers;
+}
+export function registerCursorModelLifecycle(pi, handlerOrHandlers) {
+    const handlers = normalizeLifecycleHandlers(handlerOrHandlers);
+    const sync = handlers.sync;
+    if (handlers.sessionStart || sync) {
+        pi.on("session_start", async (event, ctx) => {
+            await handlers.sessionStart?.(event, ctx);
+            await sync?.(ctx);
+        });
+    }
+    if (handlers.modelSelect || sync) {
+        pi.on("model_select", async (event, ctx) => {
+            const effectiveCtx = { ...ctx, model: event.model };
+            await handlers.modelSelect?.(event, effectiveCtx);
+            await sync?.(effectiveCtx);
+        });
+    }
+    if (handlers.turnStart || sync) {
+        pi.on("turn_start", async (event, ctx) => {
+            await handlers.turnStart?.(event, ctx);
+            await sync?.(ctx);
+        });
+    }
+    if (handlers.beforeAgentStart || sync) {
+        pi.on("before_agent_start", async (event, ctx) => {
+            await sync?.(ctx);
+            return await handlers.beforeAgentStart?.(event, ctx);
+        });
+    }
+}

package/dist/cursor-model.js

@@ -0,0 +1,5 @@
+export const CURSOR_PROVIDER = "cursor";
+export const CURSOR_SDK_API = "cursor-sdk";
+export function isCursorModel(model) {
+    return model?.provider === CURSOR_PROVIDER || model?.api === CURSOR_SDK_API;
+}

package/dist/cursor-native-replay-routing.js

@@ -0,0 +1,35 @@
+import { canRenderCursorToolNatively } from "./cursor-native-tool-display-state.js";
+import { getActiveContextToolNames } from "./cursor-context-tools.js";
+export function isNativeToolActiveInContext(toolName, activeToolNames) {
+    return activeToolNames === undefined || activeToolNames.has(toolName);
+}
+/**
+ * Canonical native replay routing for coordinator and live-run drain.
+ * Extension resync (pi active tools) is separate; this uses context.tools snapshot only.
+ */
+export function resolveNativeReplayDisposition(input) {
+    if (!input.useNativeToolReplay || !canRenderCursorToolNatively(input.toolName)) {
+        return "transcript_trace";
+    }
+    if (isNativeToolActiveInContext(input.toolName, input.activeToolNames) && input.hasLiveRun) {
+        return "queue_replay";
+    }
+    if (!isNativeToolActiveInContext(input.toolName, input.activeToolNames)) {
+        return "inactive_trace";
+    }
+    return "transcript_trace";
+}
+export function partitionNativeToolsByActiveContext(context, tools) {
+    const activeToolNames = getActiveContextToolNames(context);
+    if (!activeToolNames)
+        return { active: [...tools], inactive: [] };
+    const active = [];
+    const inactive = [];
+    for (const tool of tools) {
+        if (activeToolNames.has(tool.toolName))
+            active.push(tool);
+        else
+            inactive.push(tool);
+    }
+    return { active, inactive };
+}

package/dist/cursor-native-replay-trace.js

@@ -0,0 +1,28 @@
+import { asRecord } from "./cursor-record-utils.js";
+import { truncateCursorDisplayLine } from "./cursor-display-text.js";
+function getCursorReplayResultText(display) {
+    for (const content of display.result.content) {
+        if (content.type !== "text")
+            continue;
+        const text = truncateCursorDisplayLine(content.text);
+        if (text)
+            return text;
+    }
+    return undefined;
+}
+/** Unified inactive native-replay fallback: `title: summary` in thinking trace. */
+export function formatInactiveCursorReplayTrace(display) {
+    const details = asRecord(display.result.details);
+    const args = asRecord(display.args);
+    const title = typeof details?.title === "string" && details.title.trim()
+        ? details.title.trim()
+        : typeof args?.activityTitle === "string" && args.activityTitle.trim()
+            ? args.activityTitle.trim()
+            : `Cursor ${display.toolName}`;
+    const summary = typeof details?.summary === "string" && details.summary.trim()
+        ? details.summary.trim()
+        : typeof args?.activitySummary === "string" && args.activitySummary.trim()
+            ? args.activitySummary.trim()
+            : getCursorReplayResultText(display) ?? "completed";
+    return `${truncateCursorDisplayLine(title)}: ${truncateCursorDisplayLine(summary)}\n`;
+}

package/dist/cursor-native-tool-display-registration.js

@@ -0,0 +1,102 @@
+import { arePiToolsDisabled } from "./cursor-active-tools.js";
+import { CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES, isNativeCursorToolName, NATIVE_CURSOR_TOOL_NAMES, } from "./cursor-native-tool-names.js";
+import { isCursorModel } from "./cursor-model.js";
+import { registerCursorModelLifecycle } from "./cursor-model-lifecycle.js";
+import { isCursorNativeToolDisplayRequested, isCursorNativeToolRegistrationRequested, NATIVE_CURSOR_TOOL_DISPLAY_ENV, readBooleanEnv, registeredNativeToolNames, setCursorNativeToolDisplayRuntimeRequested, skippedNativeToolNames, } from "./cursor-native-tool-display-state.js";
+import { isCursorReplayToolName } from "./cursor-tool-presentation-registry.js";
+import { registerNativeCursorTool } from "./cursor-native-tool-display-tools.js";
+export const CURSOR_CORE_PI_REPLAY_TOOL_NAMES = ["read", "bash", "edit", "write"];
+const CORE_PI_TOOL_NAMES = new Set(CURSOR_CORE_PI_REPLAY_TOOL_NAMES);
+function isCursorCorePiReplayToolName(toolName) {
+    return CORE_PI_TOOL_NAMES.has(toolName);
+}
+function hasNonBuiltinTool(pi, toolName) {
+    const existingTool = pi.getAllTools().find((tool) => tool.name === toolName);
+    return existingTool !== undefined && existingTool.sourceInfo.source !== "builtin";
+}
+function registerNativeCursorToolsFromSet(pi, toolNames) {
+    const newlySkippedToolNames = [];
+    for (const toolName of toolNames) {
+        if (registeredNativeToolNames.has(toolName) || skippedNativeToolNames.has(toolName))
+            continue;
+        if (hasNonBuiltinTool(pi, toolName)) {
+            skippedNativeToolNames.add(toolName);
+            newlySkippedToolNames.push(toolName);
+            continue;
+        }
+        registerNativeCursorTool(pi, toolName);
+        registeredNativeToolNames.add(toolName);
+    }
+    return newlySkippedToolNames;
+}
+function notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames) {
+    if (skippedToolNames.length === 0 || readBooleanEnv(NATIVE_CURSOR_TOOL_DISPLAY_ENV) !== true || ctx.mode !== "tui")
+        return;
+    ctx.ui.notify(`Cursor native tool replay skipped for ${skippedToolNames.join(", ")} because another extension already provides ${skippedToolNames.length === 1 ? "that tool" : "those tools"}. Cursor will use scrubbed activity transcripts for skipped tools.`, "warning");
+}
+function hasAttemptedNativeCursorToolRegistration() {
+    return registeredNativeToolNames.size > 0 || skippedNativeToolNames.size > 0;
+}
+function removeRegisteredNonCoreNativeCursorTools(pi) {
+    if (registeredNativeToolNames.size === 0)
+        return;
+    const activeToolNames = new Set(pi.getActiveTools());
+    let changed = false;
+    for (const toolName of registeredNativeToolNames) {
+        if (isCursorCorePiReplayToolName(toolName))
+            continue;
+        if (!activeToolNames.delete(toolName))
+            continue;
+        changed = true;
+    }
+    if (changed)
+        pi.setActiveTools([...activeToolNames]);
+}
+export function syncRegisteredNativeCursorToolsForModel(pi, model) {
+    if (registeredNativeToolNames.size === 0)
+        return;
+    if (!isCursorModel(model)) {
+        removeRegisteredNonCoreNativeCursorTools(pi);
+        return;
+    }
+    if (arePiToolsDisabled(pi))
+        return;
+    const activeToolNames = new Set(pi.getActiveTools());
+    let changed = false;
+    for (const toolName of registeredNativeToolNames) {
+        if (isCursorReplayToolName(toolName) && !CURSOR_MODEL_ACTIVE_REPLAY_TOOL_NAMES.some((activeReplayToolName) => activeReplayToolName === toolName))
+            continue;
+        if (activeToolNames.has(toolName))
+            continue;
+        activeToolNames.add(toolName);
+        changed = true;
+    }
+    if (changed)
+        pi.setActiveTools([...activeToolNames]);
+}
+function ensureNativeCursorToolsRegisteredForModel(pi, ctx) {
+    if (!isCursorModel(ctx.model) || hasAttemptedNativeCursorToolRegistration())
+        return;
+    const nonCoreToolNames = NATIVE_CURSOR_TOOL_NAMES.filter((toolName) => !isCursorCorePiReplayToolName(toolName));
+    const skippedToolNames = [
+        ...registerNativeCursorToolsFromSet(pi, nonCoreToolNames),
+        ...registerNativeCursorToolsFromSet(pi, CURSOR_CORE_PI_REPLAY_TOOL_NAMES),
+    ];
+    notifySkippedNativeCursorToolsIfNeeded(ctx, skippedToolNames);
+}
+function ensureThenSyncNativeCursorToolsForModel(pi, ctx) {
+    const requested = isCursorNativeToolRegistrationRequested(ctx.mode);
+    setCursorNativeToolDisplayRuntimeRequested(requested);
+    if (!requested) {
+        removeRegisteredNonCoreNativeCursorTools(pi);
+        return;
+    }
+    ensureNativeCursorToolsRegisteredForModel(pi, ctx);
+    syncRegisteredNativeCursorToolsForModel(pi, ctx.model);
+}
+export function registerCursorNativeToolDisplay(pi) {
+    registerCursorModelLifecycle(pi, (ctx) => {
+        ensureThenSyncNativeCursorToolsForModel(pi, ctx);
+    });
+}
+export { isNativeCursorToolName, isCursorNativeToolDisplayRequested };