@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.1

package/src/cursor-skill-tool.ts

@@ -9,11 +9,9 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { arePiToolsDisabled } from "./cursor-active-tools.js";
-import type { CursorRuntime } from "./cursor-config.js";
 import { isCursorModel } from "./cursor-model.js";
 import { registerCursorModelLifecycle, type CursorModelLifecycleExtensionApi } from "./cursor-model-lifecycle.js";
 import { resolveCursorPiToolBridgeEnabled } from "./cursor-pi-tool-bridge-env.js";
-import { resolveEffectiveCursorConfigForContext } from "./cursor-runtime-state.js";
 
 export const CURSOR_ACTIVATE_SKILL_TOOL_NAME = "cursor_activate_skill";
 export const CURSOR_ACTIVATE_SKILL_MCP_NAME = "pi__cursor_activate_skill";
@@ -59,24 +57,16 @@ function getAvailableSkillNames(): string[] {
 	return [...currentSkillsByName.keys()].sort();
 }
 
-function resolveEffectiveRuntimeForSkillLifecycle(
-	cursorModel: boolean,
-	ctx: Pick<ExtensionContext, "cwd"> & Partial<Pick<ExtensionContext, "isProjectTrusted">>,
-): CursorRuntime {
-	return cursorModel ? resolveEffectiveCursorConfigForContext(ctx).runtime.value : "local";
-}
-
-function shouldExposeSkillTool(model: ExtensionContext["model"], runtime: CursorRuntime): boolean {
-	return runtime === "local" && isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
+function shouldExposeSkillTool(model: ExtensionContext["model"]): boolean {
+	return isCursorModel(model) && resolveCursorPiToolBridgeEnabled() && currentSkillsByName.size > 0;
 }
 
 function syncCursorSkillToolForModel(
 	pi: Pick<ExtensionAPI, "getActiveTools" | "setActiveTools">,
 	model: ExtensionContext["model"],
-	runtime: CursorRuntime,
 ): void {
 	const activeToolNames = new Set(pi.getActiveTools());
-	const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model, runtime);
+	const shouldBeActive = !arePiToolsDisabled(pi) && shouldExposeSkillTool(model);
 	const alreadyActive = activeToolNames.has(CURSOR_ACTIVATE_SKILL_TOOL_NAME);
 	if (shouldBeActive === alreadyActive) return;
 	if (shouldBeActive) {
@@ -114,10 +104,8 @@ export function resolveCursorSkillSystemPrompt(
 	systemPrompt: string,
 	model: ExtensionContext["model"],
 	systemPromptOptions?: BuildSystemPromptOptions,
-	runtime: CursorRuntime = "local",
 ): string {
 	if (!isCursorModel(model)) return systemPrompt;
-	if (runtime === "cloud") return systemPrompt.replace(AVAILABLE_SKILLS_SECTION_PATTERN, "");
 	const skills = getVisibleSkills(systemPromptOptions?.skills);
 	if (skills.length === 0) return systemPrompt;
 	const replacement = formatCursorSkillsForPrompt(skills);
@@ -231,9 +219,9 @@ export function registerCursorSkillTool(pi: CursorSkillToolExtensionApi): void {
 		},
 	});
 
-	const clearSkillsAndSync = (model: ExtensionContext["model"], runtime: CursorRuntime = "local"): void => {
+	const clearSkillsAndSync = (model: ExtensionContext["model"]): void => {
 		setCurrentSkills([]);
-		syncCursorSkillToolForModel(pi, model, runtime);
+		syncCursorSkillToolForModel(pi, model);
 	};
 
 	registerCursorModelLifecycle(pi, {
@@ -244,21 +232,17 @@ export function registerCursorSkillTool(pi: CursorSkillToolExtensionApi): void {
 			clearSkillsAndSync(event.model);
 		},
 		turnStart: (_event, ctx) => {
-			const cursorModel = isCursorModel(ctx.model);
-			const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
-			if (!cursorModel || runtime === "cloud") setCurrentSkills([]);
-			syncCursorSkillToolForModel(pi, ctx.model, runtime);
+			if (!isCursorModel(ctx.model)) setCurrentSkills([]);
+			syncCursorSkillToolForModel(pi, ctx.model);
 		},
 		beforeAgentStart: (event, ctx) => {
-			const cursorModel = isCursorModel(ctx.model);
-			const runtime = resolveEffectiveRuntimeForSkillLifecycle(cursorModel, ctx);
-			if (cursorModel && runtime === "local") {
+			if (isCursorModel(ctx.model)) {
 				setCurrentSkills(event.systemPromptOptions?.skills);
 			} else {
 				setCurrentSkills([]);
 			}
-			syncCursorSkillToolForModel(pi, ctx.model, runtime);
-			const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions, runtime);
+			syncCursorSkillToolForModel(pi, ctx.model);
+			const resolved = resolveCursorSkillSystemPrompt(event.systemPrompt, ctx.model, event.systemPromptOptions);
 			if (resolved === event.systemPrompt) return undefined;
 			return { systemPrompt: resolved };
 		},

package/src/cursor-state.ts

@@ -42,16 +42,14 @@ import {
 } from "./cursor-config.js";
 import {
 	consumeCursorLocalForceOverride,
-	CURSOR_RUNTIME_ENTRY_TYPE,
 	formatCursorStatus,
 	getCursorCliConfig,
 	getCursorSessionConfig,
-	registerCursorCloudRuntimeControls,
+	registerCursorLocalRuntimeFlags,
 	resetCursorRuntimeStateForTests,
 	resolveCursorStatusRuntime,
 	resolveEffectiveCursorConfigForContext,
 	restoreCursorCliState,
-	restoreSessionCursorRuntimeState,
 	type CursorRuntimeStateExtensionApi,
 } from "./cursor-runtime-state.js";
 
@@ -178,7 +176,6 @@ function restoreSessionCursorMode(branch: readonly SessionEntry[]): void {
 
 function restoreSessionCursorPreferences(ctx: { sessionManager: Pick<ExtensionContext["sessionManager"], "getBranch"> }): void {
 	const branch = ctx.sessionManager.getBranch();
-	restoreSessionCursorRuntimeState(branch);
 	restoreSessionFastPreferences(branch);
 	restoreSessionCursorMode(branch);
 	restoreSessionCursorHttp1(branch);
@@ -266,14 +263,13 @@ function updateCursorStatus(ctx: CursorStatusContext & Pick<ExtensionContext, "m
 	const modeResolution = resolveCursorAgentMode();
 	const mode = modeResolution.kind === "invalid" ? "invalid" : modeResolution.mode;
 	if (resolution.kind === "invalid") {
-		ctx.ui.setStatus("cursor", formatCursorStatus("invalid", undefined, mode));
+		ctx.ui.setStatus("cursor", formatCursorStatus(undefined, "invalid"));
 		return;
 	}
-	const runtime = resolution.runtime.value;
-	const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
+	const fast = metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
 	ctx.ui.setStatus(
 		"cursor",
-		formatCursorStatus(runtime, fast, mode, resolution.useHttp1ForAgent.value),
+		formatCursorStatus(fast, mode, resolution.useHttp1ForAgent.value),
 	);
 }
 
@@ -432,7 +428,7 @@ export function getEffectiveFastForModelId(modelId: string): boolean | undefined
 }
 
 export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtensionApi): void {
-	registerCursorCloudRuntimeControls(pi, { refreshStatus: updateCursorStatus });
+	registerCursorLocalRuntimeFlags(pi);
 
 	pi.registerFlag("cursor-fast", {
 		description: "Force Cursor fast mode for this run when the selected Cursor model supports it",
@@ -673,7 +669,6 @@ export const __testUtils = {
 	FAST_ENTRY_TYPE,
 	MODE_ENTRY_TYPE,
 	CURSOR_HTTP1_ENTRY_TYPE,
-	RUNTIME_ENTRY_TYPE: CURSOR_RUNTIME_ENTRY_TYPE,
 	DEFAULT_CURSOR_AGENT_MODE,
 	getConfigPath,
 	loadGlobalFastPreferences,

package/src/cursor-usage-accounting.ts

@@ -7,7 +7,6 @@ import {
 	type CursorPromptOptions,
 } from "./context.js";
 import { asRecord, getNumber } from "./cursor-record-utils.js";
-import type { CursorRuntime } from "./cursor-config.js";
 
 export interface CursorUsagePromptOptions extends CursorPromptOptions {
 	maxInputTokens: number;
@@ -110,7 +109,6 @@ export function isCursorSdkUsageSafeForPiMessage(turnUsage: CursorSdkTurnUsage,
 }
 
 export interface CursorSdkUsageApplyOptions {
-	runtime: CursorRuntime;
 	turn?: CursorSdkTurnUsage;
 	billed?: CursorSdkTurnUsage;
 }
@@ -209,7 +207,7 @@ export function applyCursorUsage(
 	sdkUsage?: CursorSdkUsageApplyOptions,
 ): void {
 	const billed = sdkUsage?.billed;
-	const localTurn = sdkUsage?.runtime === "local" ? sdkUsage.turn : undefined;
+	const localTurn = sdkUsage?.turn;
 	if (billed && isCursorSdkUsagePartitionSafe(billed, model)) {
 		applyCursorSdkUsage(partial, billed);
 		applyResolvedCursorOccupancy(partial, model, context, localTurn);

package/src/index.ts

@@ -16,6 +16,11 @@ import { registerCursorAgentsContextDedup } from "./cursor-agents-context-regist
 import { registerCursorOverflowNormalization } from "./cursor-provider-overflow.js";
 import { registerCursorSdkSessionProcessErrorGuard } from "./cursor-sdk-process-error-guard.js";
 import { prepareCursorSessionForCompaction } from "./cursor-session-compaction-prep.js";
+import {
+	claimCursorExtensionFactory,
+	registerCursorExtensionFactoryRelease,
+	releaseCursorExtensionFactory,
+} from "./cursor-extension-factory-guard.js";
 
 type CursorExtensionApi =
 	& Pick<ExtensionAPI, "registerProvider" | "registerCommand" | "on">
@@ -31,7 +36,8 @@ type CursorExtensionApi =
 	& Parameters<typeof registerCursorFallbackIssueWarning>[0]
 	& Parameters<typeof registerCursorAgentsContextDedup>[0]
 	& Parameters<typeof registerCursorOverflowNormalization>[0]
-	& Parameters<typeof registerCursorSdkSessionProcessErrorGuard>[0];
+	& Parameters<typeof registerCursorSdkSessionProcessErrorGuard>[0]
+	& Parameters<typeof registerCursorExtensionFactoryRelease>[0];
 
 function createCursorProviderConfig(models: ProviderModelConfig[]): ProviderConfig {
 	return {
@@ -49,55 +55,70 @@ function registerCursorProvider(pi: Pick<ExtensionAPI, "registerProvider">, mode
 }
 
 export default async function (pi: CursorExtensionApi) {
-	// Session cwd must register before other session_start listeners that depend on it.
-	registerCursorSessionScope(pi);
-	registerCursorSessionAgentLineage(pi);
-	registerCursorSessionAgentLifecycle(pi);
-	registerCursorSessionAgentResume(pi);
-	pi.on("session_before_compact", async () => {
-		await prepareCursorSessionForCompaction();
-	});
-	registerCursorRuntimeControls(pi);
-	registerCursorNativeToolDisplay(pi);
-	registerCursorQuestionTool(pi);
-	registerCursorSkillTool(pi);
-	registerCursorPiToolBridge(pi);
-	registerCursorAgentsContextDedup(pi);
-	registerCursorOverflowNormalization(pi);
-	let fallbackIssue: CursorModelFallbackIssue | undefined;
-	const models = await discoverModels({
-		onFallback: (issue) => {
-			fallbackIssue = issue;
-		},
-	});
+	const factoryClaim = claimCursorExtensionFactory();
+	if (factoryClaim.kind === "nested") return;
 
-	if (fallbackIssue) {
-		registerCursorFallbackIssueWarning(pi, fallbackIssue);
-	}
+	try {
+		// Discover first. A discovery failure must not leave process-global
+		// registrars from a discarded extension load.
+		let fallbackIssue: CursorModelFallbackIssue | undefined;
+		const models = await discoverModels({
+			onFallback: (issue) => {
+				fallbackIssue = issue;
+			},
+		});
+
+		// Session cwd must register before other session_start listeners that depend on it.
+		registerCursorSessionScope(pi);
+		registerCursorSessionAgentLineage(pi);
+		registerCursorSessionAgentLifecycle(pi);
+		registerCursorSessionAgentResume(pi);
+		pi.on("session_before_compact", async () => {
+			await prepareCursorSessionForCompaction();
+		});
+		registerCursorRuntimeControls(pi);
+		registerCursorNativeToolDisplay(pi);
+		registerCursorQuestionTool(pi);
+		registerCursorSkillTool(pi);
+		registerCursorPiToolBridge(pi);
+		registerCursorAgentsContextDedup(pi);
+		registerCursorOverflowNormalization(pi);
 
-	pi.registerCommand("cursor-refresh-models", {
-		description: "Refresh the live Cursor model catalog without restarting pi",
-		handler: async (_args, ctx) => {
-			let refreshFallbackIssue: CursorModelFallbackIssue | undefined;
-			const apiKey = resolveCursorApiKey(await ctx.modelRegistry.getApiKeyForProvider("cursor"));
-			const refreshedModels = await discoverModels({
-				apiKey,
-				forceRefresh: true,
-				onFallback: (issue) => {
-					refreshFallbackIssue = issue;
-				},
-			});
-			registerCursorProvider(pi, refreshedModels);
-			if (!ctx.hasUI) return;
-			if (refreshFallbackIssue) {
-				ctx.ui.notify(`Cursor model catalog refresh did not use a live catalog: ${refreshFallbackIssue.message}`, "warning");
-			} else {
-				ctx.ui.notify(`Cursor model catalog refreshed with ${refreshedModels.length} model${refreshedModels.length === 1 ? "" : "s"}.`, "info");
-			}
-		},
-	});
+		if (fallbackIssue) {
+			registerCursorFallbackIssueWarning(pi, fallbackIssue);
+		}
 
-	registerCursorProvider(pi, models);
-	// Register last so session_shutdown cleanup remains protected until other Cursor handlers finish.
-	registerCursorSdkSessionProcessErrorGuard(pi);
+		pi.registerCommand("cursor-refresh-models", {
+			description: "Refresh the live Cursor model catalog without restarting pi",
+			handler: async (_args, ctx) => {
+				let refreshFallbackIssue: CursorModelFallbackIssue | undefined;
+				const apiKey = resolveCursorApiKey(await ctx.modelRegistry.getApiKeyForProvider("cursor"));
+				const refreshedModels = await discoverModels({
+					apiKey,
+					forceRefresh: true,
+					onFallback: (issue) => {
+						refreshFallbackIssue = issue;
+					},
+				});
+				registerCursorProvider(pi, refreshedModels);
+				if (!ctx.hasUI) return;
+				if (refreshFallbackIssue) {
+					ctx.ui.notify(`Cursor model catalog refresh did not use a live catalog: ${refreshFallbackIssue.message}`, "warning");
+				} else {
+					ctx.ui.notify(`Cursor model catalog refreshed with ${refreshedModels.length} model${refreshedModels.length === 1 ? "" : "s"}.`, "info");
+				}
+			},
+		});
+
+		registerCursorProvider(pi, models);
+		// Keep the process error guard near the end so earlier Cursor cleanup
+		// remains protected during session shutdown.
+		registerCursorSdkSessionProcessErrorGuard(pi);
+		// Register last so ownership remains protected until all other Cursor
+		// session_shutdown handlers finish.
+		registerCursorExtensionFactoryRelease(pi, factoryClaim);
+	} catch (error) {
+		releaseCursorExtensionFactory(factoryClaim.token);
+		throw error;
+	}
 }