pi-cursor-sdk 0.1.60 → 0.1.61

package/src/cursor-state.ts

@@ -6,6 +6,14 @@ import {
 	resolveCursorToolManifestEnabled,
 } from "./cursor-tool-manifest.js";
 import { runCursorSessionAgentCleanupCommand } from "./cursor-session-agent-cleanup.js";
+import {
+	CURSOR_HTTP1_ENTRY_TYPE,
+	getStoredCursorHttp1Enabled,
+	isCursorHttp1EntryData,
+	setCursorHttp1GlobalPreferenceAuthoritative,
+	setStoredCursorHttp1Enabled,
+	type CursorHttp1EntryData,
+} from "./cursor-http1.js";
 import {
 	buildCursorPiToolBridgeSnapshot,
 	CURSOR_PI_TOOL_BRIDGE_ENV,
@@ -26,10 +34,9 @@ import {
 	cursorFastDefaultsFromConfig,
 	getCursorSdkUserConfigPath,
 	loadCursorSdkUserConfig,
+	mergeCursorSdkConfigForUpdate,
 	resolveCursorFastDefault,
-	saveCursorSdkUserConfig,
-	withCursorFastDefaults,
-	type CursorSdkConfig,
+	updateCursorSdkConfig,
 } from "./cursor-config.js";
 import {
 	consumeCursorLocalForceOverride,
@@ -79,6 +86,7 @@ type CursorCliModeState =
 	| { kind: "invalid"; raw: string; message: string };
 
 const sessionFastPreferences = new Map<string, boolean>();
+const authoritativeGlobalFastPreferenceIds = new Set<string>();
 let globalFastPreferences = new Map<string, boolean>();
 let cliForceFast = false;
 let cliForceNoFast = false;
@@ -118,9 +126,30 @@ function loadGlobalFastPreferences(): Map<string, boolean> {
 	return cursorFastDefaultsFromConfig(loadCursorSdkUserConfig());
 }
 
-function saveGlobalFastPreferences(): void {
-	const currentConfig: CursorSdkConfig = loadCursorSdkUserConfig();
-	saveCursorSdkUserConfig(withCursorFastDefaults(currentConfig, globalFastPreferences));
+function saveGlobalFastPreference(modelId: string, fast: boolean): void {
+	updateCursorSdkConfig(
+		getConfigPath(),
+		(current) => {
+			const fastDefaults = { ...asRecord(current.fastDefaults), [modelId]: fast };
+			return {
+				...current,
+				fastDefaults: Object.fromEntries(
+					Object.entries(fastDefaults).sort(([a], [b]) => a.localeCompare(b)),
+				),
+			};
+		},
+		{ newFileMode: 0o600 },
+	);
+}
+
+function saveGlobalCursorHttp1Enabled(enabled: boolean): void {
+	updateCursorSdkConfig(
+		getConfigPath(),
+		(current) => mergeCursorSdkConfigForUpdate(current, {
+			local: { useHttp1ForAgent: enabled },
+		}),
+		{ newFileMode: 0o600 },
+	);
 }
 
 function restoreSessionFastPreferences(branch: readonly SessionEntry[]): void {
@@ -149,6 +178,17 @@ function restoreSessionCursorPreferences(ctx: { sessionManager: Pick<ExtensionCo
 	restoreSessionCursorRuntimeState(branch);
 	restoreSessionFastPreferences(branch);
 	restoreSessionCursorMode(branch);
+	restoreSessionCursorHttp1(branch);
+}
+
+function restoreSessionCursorHttp1(branch: readonly SessionEntry[]): void {
+	setStoredCursorHttp1Enabled(undefined);
+	for (const entry of branch) {
+		if (entry.type !== "custom" || entry.customType !== CURSOR_HTTP1_ENTRY_TYPE) continue;
+		if (isCursorHttp1EntryData(entry.data)) {
+			setStoredCursorHttp1Enabled(entry.data.enabled);
+		}
+	}
 }
 
 function getFastPreferenceModelId(metadata: NonNullable<ReturnType<typeof getCursorModelMetadata>>): string {
@@ -174,7 +214,9 @@ function getEffectiveFast(modelId: string): boolean | undefined {
 		cliForceNoFast,
 		cliForceFast,
 		aliasOverride: metadata.fastOverride,
-		sessionValue: getMapFastPreference(sessionFastPreferences, metadata),
+		sessionValue: authoritativeGlobalFastPreferenceIds.has(getFastPreferenceModelId(metadata))
+			? undefined
+			: getMapFastPreference(sessionFastPreferences, metadata),
 		userValue: getMapFastPreference(globalFastPreferences, metadata),
 		modelDefault: metadata.defaultFast,
 	}).value;
@@ -226,7 +268,10 @@ function updateCursorStatus(ctx: CursorStatusContext & Pick<ExtensionContext, "m
 	}
 	const runtime = resolution.runtime.value;
 	const fast = runtime === "cloud" ? undefined : metadata?.supportsFast ? getEffectiveFast(model.id) : undefined;
-	ctx.ui.setStatus("cursor", formatCursorStatus(runtime, fast, mode));
+	ctx.ui.setStatus(
+		"cursor",
+		formatCursorStatus(runtime, fast, mode, resolution.useHttp1ForAgent.value),
+	);
 }
 
 function getCurrentCursorMetadata(ctx: Pick<ExtensionContext, "model">) {
@@ -243,28 +288,30 @@ function restoreMapValue(map: Map<string, boolean>, key: string, previous: boole
 	}
 }
 
-function persistFastPreference(pi: Pick<ExtensionAPI, "appendEntry">, modelId: string, fast: boolean): void {
+function persistFastPreference(
+	pi: Pick<ExtensionAPI, "appendEntry">,
+	modelId: string,
+	fast: boolean,
+): unknown | undefined {
 	const previousSession = sessionFastPreferences.get(modelId);
 	const previousGlobal = globalFastPreferences.get(modelId);
-	let savedGlobal = false;
 	sessionFastPreferences.set(modelId, fast);
 	globalFastPreferences.set(modelId, fast);
 	try {
-		saveGlobalFastPreferences();
-		savedGlobal = true;
-		pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { modelId, fast });
+		saveGlobalFastPreference(modelId, fast);
 	} catch (error) {
 		restoreMapValue(sessionFastPreferences, modelId, previousSession);
 		restoreMapValue(globalFastPreferences, modelId, previousGlobal);
-		if (savedGlobal) {
-			try {
-				saveGlobalFastPreferences();
-			} catch {
-				// Preserve the original append failure reported to the user.
-			}
-		}
 		throw error;
 	}
+	try {
+		pi.appendEntry<CursorFastEntryData>(FAST_ENTRY_TYPE, { modelId, fast });
+		authoritativeGlobalFastPreferenceIds.delete(modelId);
+		return undefined;
+	} catch (error) {
+		authoritativeGlobalFastPreferenceIds.add(modelId);
+		return error;
+	}
 }
 
 function persistCursorModePreference(pi: Pick<ExtensionAPI, "appendEntry">, mode: AgentModeOption): void {
@@ -278,6 +325,28 @@ function persistCursorModePreference(pi: Pick<ExtensionAPI, "appendEntry">, mode
 	}
 }
 
+function persistCursorHttp1Preference(
+	pi: Pick<ExtensionAPI, "appendEntry">,
+	enabled: boolean,
+): unknown | undefined {
+	const previousSession = getStoredCursorHttp1Enabled();
+	setStoredCursorHttp1Enabled(enabled);
+	try {
+		saveGlobalCursorHttp1Enabled(enabled);
+	} catch (error) {
+		setStoredCursorHttp1Enabled(previousSession);
+		throw error;
+	}
+	try {
+		pi.appendEntry<CursorHttp1EntryData>(CURSOR_HTTP1_ENTRY_TYPE, { enabled });
+		setCursorHttp1GlobalPreferenceAuthoritative(false);
+		return undefined;
+	} catch (error) {
+		setCursorHttp1GlobalPreferenceAuthoritative(true);
+		return error;
+	}
+}
+
 function restoreCliCursorMode(raw: boolean | string | undefined): void {
 	cliCursorModeState = { kind: "unset" };
 	if (raw === undefined || raw === "" || raw === false) return;
@@ -399,14 +468,22 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 			const preferenceModelId = getFastPreferenceModelId(metadata);
 			const current = getEffectiveFast(metadata.piModelId) ?? false;
 			const next = !current;
+			let appendError: unknown;
 			try {
-				persistFastPreference(pi, preferenceModelId, next);
+				appendError = persistFastPreference(pi, preferenceModelId, next);
 			} catch (error) {
 				updateCursorStatus(ctx);
 				ctx.ui.notify(`Failed to save Cursor fast preference: ${error instanceof Error ? error.message : String(error)}`, "error");
 				return;
 			}
 			updateCursorStatus(ctx);
+			if (appendError !== undefined) {
+				ctx.ui.notify(
+					`Cursor fast ${next ? "enabled" : "disabled"} was saved globally, but persisting the session entry failed: ${appendError instanceof Error ? appendError.message : String(appendError)}`,
+					"error",
+				);
+				return;
+			}
 			ctx.ui.notify(`Cursor fast ${next ? "enabled" : "disabled"}`, "info");
 		},
 	});
@@ -418,6 +495,64 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 		},
 	});
 
+	pi.registerCommand("cursor-http", {
+		description: "Toggle Cursor SDK HTTP/1.1/SSE transport compatibility mode",
+		handler: async (args, ctx) => {
+			const usage = "Usage: /cursor-http [on|off|toggle]";
+			const normalized = args.trim().toLowerCase();
+			const resolution = resolveCursorStatusRuntime(ctx);
+			if (resolution.kind === "invalid") {
+				ctx.ui.notify(resolution.message, "error");
+				return;
+			}
+			const setting = resolution.useHttp1ForAgent;
+			if (!normalized) {
+				ctx.ui.notify(
+					`Cursor HTTP/1.1/SSE transport is ${setting.value ? "enabled" : "disabled"} (source: ${setting.source}). ${usage}`,
+					"info",
+				);
+				return;
+			}
+			const next = normalized === "on"
+				? true
+				: normalized === "off"
+					? false
+					: normalized === "toggle"
+						? !setting.value
+						: undefined;
+			if (next === undefined) {
+				ctx.ui.notify(
+					`Invalid Cursor HTTP transport mode "${args.trim()}". ${usage}`,
+					"error",
+				);
+				return;
+			}
+			let appendError: unknown;
+			try {
+				appendError = persistCursorHttp1Preference(pi, next);
+			} catch (error) {
+				updateCursorStatus(ctx);
+				ctx.ui.notify(
+					`Failed to save Cursor HTTP/1.1 preference: ${error instanceof Error ? error.message : String(error)}`,
+					"error",
+				);
+				return;
+			}
+			updateCursorStatus(ctx);
+			if (appendError !== undefined) {
+				ctx.ui.notify(
+					`Cursor HTTP/1.1 preference was saved globally, but persisting the session entry failed: ${appendError instanceof Error ? appendError.message : String(appendError)}`,
+					"error",
+				);
+				return;
+			}
+			ctx.ui.notify(
+				`Cursor HTTP/1.1/SSE transport ${next ? "enabled" : "disabled"}`,
+				"info",
+			);
+		},
+	});
+
 	pi.registerCommand("cursor-local-resume-cleanup", {
 		description: "Dry-run or delete recorded superseded local Cursor SDK agents",
 		handler: async (args, ctx) => {
@@ -495,6 +630,8 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 
 	registerCursorModelLifecycle(pi, {
 		sessionStart: (_event, ctx) => {
+			authoritativeGlobalFastPreferenceIds.clear();
+			setCursorHttp1GlobalPreferenceAuthoritative(false);
 			globalFastPreferences = loadGlobalFastPreferences();
 			cliForceFast = pi.getFlag("cursor-fast") === true;
 			cliForceNoFast = pi.getFlag("cursor-no-fast") === true;
@@ -511,14 +648,18 @@ export function registerCursorRuntimeControls(pi: CursorRuntimeControlsExtension
 
 function resetCursorModeStateForTests(): void {
 	sessionCursorAgentMode = undefined;
+	setCursorHttp1GlobalPreferenceAuthoritative(false);
+	setStoredCursorHttp1Enabled(undefined);
 	cliCursorModeState = { kind: "unset" };
 	resetCursorRuntimeStateForTests();
 	invalidCursorModeNotifiedSessionScopeKeys.clear();
+	authoritativeGlobalFastPreferenceIds.clear();
 }
 
 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,