pi-cursor-sdk 0.1.59 → 0.1.61

package/src/cursor-cloud-options.ts

@@ -1,14 +1,11 @@
-import { execFileSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, join } from "node:path";
 import type { AgentModeOption, AgentOptions, ModelSelection } from "@cursor/sdk";
 import { isCursorCloudEnvironmentType, type CursorResolvedSdkConfig } from "./cursor-config.js";
-
-export interface CursorCloudLocalState {
-	insideGitRepo: boolean;
-	dirty: boolean;
-	unpushed: boolean;
-}
+import {
+	normalizeCursorCloudStartingRef,
+	parseCursorCloudRepositoryUrl,
+	type CursorCloudLocalState,
+	type CursorCloudLocalStateUnknownReason,
+} from "./cursor-cloud-local-state.js";
 
 export interface CursorCloudPreflightIssue {
 	code:
@@ -20,6 +17,7 @@ export interface CursorCloudPreflightIssue {
 		| "cloud_environment_type_required"
 		| "cloud_environment_repo_conflict"
 		| "cloud_branch_repo_required"
+		| "cloud_branch_invalid"
 		| "cloud_repo_invalid";
 	message: string;
 }
@@ -29,63 +27,21 @@ export interface CursorCloudPreflightResult {
 	issues: CursorCloudPreflightIssue[];
 }
 
-type GitRunner = (cwd: string, args: string[]) => string | undefined;
-
 const CLOUD_REPO_URL_MESSAGE = "Cursor cloud repository must be an HTTPS repository URL without embedded credentials, query parameters, or fragments.";
-
-export function parseCursorCloudRepositoryUrl(value: string | undefined): string | undefined {
-	const trimmed = value?.trim();
-	if (!trimmed) return undefined;
-	try {
-		const url = new URL(trimmed);
-		if (
-			url.protocol !== "https:" ||
-			url.username !== "" ||
-			url.password !== "" ||
-			url.search !== "" ||
-			url.hash !== "" ||
-			url.pathname === "/"
-		) return undefined;
-		return trimmed;
-	} catch {
-		return undefined;
-	}
-}
-
-function git(cwd: string, args: string[]): string | undefined {
-	try {
-		return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
-	} catch {
-		return undefined;
-	}
-}
-
-function hasGitMetadata(cwd: string): boolean {
-	let current = cwd;
-	while (true) {
-		if (existsSync(join(current, ".git"))) return true;
-		const parent = dirname(current);
-		if (parent === current) return false;
-		current = parent;
-	}
-}
-
-export function inspectCursorCloudLocalState(cwd: string, runGit: GitRunner = git): CursorCloudLocalState {
-	const insideGitRepo = runGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
-	if (insideGitRepo !== "true") {
-		return hasGitMetadata(cwd)
-			? { insideGitRepo: true, dirty: true, unpushed: true }
-			: { insideGitRepo: false, dirty: false, unpushed: false };
-	}
-	const status = runGit(cwd, ["status", "--porcelain=v1"]);
-	const dirty = status === undefined || status.length > 0;
-	const hasHead = runGit(cwd, ["rev-parse", "--verify", "HEAD"]) !== undefined;
-	const upstream = runGit(cwd, ["rev-parse", "--abbrev-ref", "--symbolic-full-name", "@{upstream}"]);
-	const ahead = upstream ? runGit(cwd, ["rev-list", "--count", "@{upstream}..HEAD"]) : undefined;
-	const aheadCount = ahead === undefined ? Number.NaN : Number(ahead);
-	const unpushed = hasHead && (!upstream || !Number.isFinite(aheadCount) || aheadCount > 0);
-	return { insideGitRepo: true, dirty, unpushed };
-}
+const CLOUD_STARTING_REF_MESSAGE = "Cursor cloud branch/ref must be a valid Git branch name, refs/heads/<branch>, or full commit SHA; invalid branch names and other refs/* are unsupported.";
+const CLOUD_LOCAL_STATE_REASON_LABELS: Record<CursorCloudLocalStateUnknownReason["code"], string> = {
+	bare_repo: "the repository is bare",
+	repository_detection_failed: "Git could not determine whether the working directory is a repository",
+	status_failed: "Git could not determine whether the worktree or index is clean",
+	index_failed: "Git index inspection failed",
+	hidden_index_state: "the index hides worktree changes",
+	history_probe_failed: "Git could not inspect replacement or graft history overrides",
+	history_overrides: "replacement refs or graft metadata are present",
+	head_unavailable: "local HEAD is unavailable",
+	unverified_target: "the cloud target has no locally verified tracking ref",
+	target_probe_failed: "Git failed while resolving the cloud target",
+	comparison_failed: "the local HEAD comparison failed",
+};
 
 export function buildCursorCloudAgentOptions(options: {
 	apiKey: string;
@@ -101,6 +57,8 @@ export function buildCursorCloudAgentOptions(options: {
 	const configuredRepo = resolvedConfig.cloud.repo.value;
 	const repo = parseCursorCloudRepositoryUrl(configuredRepo);
 	if (configuredRepo && !repo) throw new Error(CLOUD_REPO_URL_MESSAGE);
+	const startingRef = normalizeCursorCloudStartingRef(resolvedConfig.cloud.branch.value);
+	if (startingRef.kind === "unsupported") throw new Error(CLOUD_STARTING_REF_MESSAGE);
 	const cloud = {
 		...(isCursorCloudEnvironmentType(environmentType)
 			? {
@@ -115,12 +73,18 @@ export function buildCursorCloudAgentOptions(options: {
 					repos: [
 						{
 							url: repo,
-							...(resolvedConfig.cloud.branch.value ? { startingRef: resolvedConfig.cloud.branch.value } : {}),
+							...(startingRef.kind === "branch" || startingRef.kind === "commit" ? { startingRef: startingRef.value } : {}),
 						},
 					],
 				}
 			: {}),
 		...(resolvedConfig.cloud.directPush.value ? { workOnCurrentBranch: true } : {}),
+		...(resolvedConfig.cloud.autoCreatePR.source !== "builtin"
+			? { autoCreatePR: resolvedConfig.cloud.autoCreatePR.value }
+			: {}),
+		...(resolvedConfig.cloud.skipReviewerRequest.source !== "builtin"
+			? { skipReviewerRequest: resolvedConfig.cloud.skipReviewerRequest.value }
+			: {}),
 	};
 	return {
 		apiKey: options.apiKey,
@@ -133,7 +97,7 @@ export function buildCursorCloudAgentOptions(options: {
 
 export function preflightCursorCloudRuntime(options: {
 	resolvedConfig: CursorResolvedSdkConfig;
-	localState?: CursorCloudLocalState;
+	localState: CursorCloudLocalState;
 	hasPriorContext?: boolean;
 }): CursorCloudPreflightResult {
 	const { resolvedConfig } = options;
@@ -151,13 +115,22 @@ export function preflightCursorCloudRuntime(options: {
 		});
 	}
 	if (
-		options.localState?.insideGitRepo &&
-		(options.localState.dirty || options.localState.unpushed) &&
+		options.localState.insideGitRepo !== false &&
+		(options.localState.dirty !== false || options.localState.comparison !== "contains_head") &&
 		!resolvedConfig.cloud.allowLocalState.value
 	) {
+		const causes: string[] = [];
+		if (options.localState.dirty === true) causes.push("the worktree or index is dirty");
+		if (options.localState.dirty === "unknown") causes.push("Git could not determine whether the worktree or index is clean");
+		if (options.localState.comparison === "unpushed") causes.push("local HEAD contains unpushed commits");
+		if (options.localState.comparison === "unknown") {
+			causes.push(...options.localState.reasons
+				.filter((reason) => reason.code !== "status_failed")
+				.map((reason) => CLOUD_LOCAL_STATE_REASON_LABELS[reason.code]));
+		}
 		issues.push({
 			code: "local_state_not_allowed",
-			message: "Cursor cloud runtime cannot see dirty or unpushed local state; pass --cursor-cloud-allow-local-state only after accepting that risk.",
+			message: `Cursor cloud runtime cannot safely omit local state because ${causes.join("; ")}. Configure an explicit repository branch/ref with current local tracking evidence, or pass --cursor-cloud-allow-local-state only after accepting that risk.`,
 		});
 	}
 	if (resolvedConfig.cloud.envNames.value.length > 0 || resolvedConfig.cloud.envFromFiles.value) {
@@ -178,6 +151,9 @@ export function preflightCursorCloudRuntime(options: {
 			message: "Cursor cloud branch/ref requires --cursor-cloud-repo because the installed Cursor SDK supports startingRef only on cloud.repos entries.",
 		});
 	}
+	if (normalizeCursorCloudStartingRef(resolvedConfig.cloud.branch.value).kind === "unsupported") {
+		issues.push({ code: "cloud_branch_invalid", message: CLOUD_STARTING_REF_MESSAGE });
+	}
 	const environment = resolvedConfig.cloud.environment.value;
 	if (environment?.type && !isCursorCloudEnvironmentType(environment.type)) {
 		issues.push({

package/src/cursor-config.ts

@@ -1,5 +1,16 @@
 import { randomUUID } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import {
+	chmodSync,
+	closeSync,
+	existsSync,
+	mkdirSync,
+	openSync,
+	readFileSync,
+	renameSync,
+	rmSync,
+	statSync,
+	writeFileSync,
+} from "node:fs";
 import { dirname, join } from "node:path";
 import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { parseOptionalEnvBoolean } from "./cursor-env-boolean.js";
@@ -12,6 +23,8 @@ export const CURSOR_CLOUD_REPO_ENV = "PI_CURSOR_CLOUD_REPO";
 export const CURSOR_CLOUD_BRANCH_ENV = "PI_CURSOR_CLOUD_BRANCH";
 export const CURSOR_CLOUD_CONTEXT_ENV = "PI_CURSOR_CLOUD_CONTEXT";
 export const CURSOR_CLOUD_DIRECT_PUSH_ENV = "PI_CURSOR_CLOUD_DIRECT_PUSH";
+export const CURSOR_CLOUD_AUTO_CREATE_PR_ENV = "PI_CURSOR_CLOUD_AUTO_CREATE_PR";
+export const CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV = "PI_CURSOR_CLOUD_SKIP_REVIEWER_REQUEST";
 export const CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV = "PI_CURSOR_CLOUD_ALLOW_LOCAL_STATE";
 export const CURSOR_CLOUD_ENV_ENV = "PI_CURSOR_CLOUD_ENV";
 export const CURSOR_CLOUD_ENV_FROM_FILES_ENV = "PI_CURSOR_CLOUD_ENV_FROM_FILES";
@@ -22,6 +35,7 @@ export const CURSOR_AUTO_REVIEW_ENV = "PI_CURSOR_AUTO_REVIEW";
 export const CURSOR_SANDBOX_ENV = "PI_CURSOR_SANDBOX";
 export const CURSOR_LOCAL_FORCE_ENV = "PI_CURSOR_LOCAL_FORCE";
 export const CURSOR_LOCAL_RESUME_ENV = "PI_CURSOR_LOCAL_RESUME";
+export const CURSOR_HTTP1_ENV = "PI_CURSOR_HTTP_1_1";
 
 export type CursorConfigSource = "cli" | "environment" | "project" | "user" | "session" | "model-alias" | "builtin";
 export type CursorConfigTrustLevel = "one-shot" | "environment" | "trusted-project" | "user" | "session" | "model-catalog" | "builtin";
@@ -42,6 +56,8 @@ export interface CursorSdkConfig {
 		branch?: string;
 		contextHandoff?: CursorCloudContextHandoff;
 		directPush?: boolean;
+		autoCreatePR?: boolean;
+		skipReviewerRequest?: boolean;
 		allowLocalState?: boolean;
 		envNames?: string[];
 		envFromFiles?: boolean;
@@ -56,6 +72,7 @@ export interface CursorSdkConfig {
 		};
 		force?: boolean;
 		resume?: boolean;
+		useHttp1ForAgent?: boolean;
 	};
 }
 
@@ -82,6 +99,8 @@ export interface CursorResolvedSdkConfig {
 		branch: CursorResolvedSetting<string | undefined>;
 		contextHandoff: CursorResolvedSetting<CursorCloudContextHandoff>;
 		directPush: CursorResolvedSetting<boolean>;
+		autoCreatePR: CursorResolvedSetting<boolean>;
+		skipReviewerRequest: CursorResolvedSetting<boolean>;
 		allowLocalState: CursorResolvedSetting<boolean>;
 		envNames: CursorResolvedSetting<string[]>;
 		envFromFiles: CursorResolvedSetting<boolean>;
@@ -93,6 +112,7 @@ export interface CursorResolvedSdkConfig {
 		sandboxEnabled: CursorResolvedSetting<boolean>;
 		force: CursorResolvedSetting<boolean>;
 		resume: CursorResolvedSetting<boolean>;
+		useHttp1ForAgent: CursorResolvedSetting<boolean>;
 	};
 }
 
@@ -143,6 +163,8 @@ const BUILT_IN_CURSOR_CONFIG: Required<Pick<CursorSdkConfig, "runtime">> & {
 		branch: "",
 		contextHandoff: "fresh",
 		directPush: false,
+		autoCreatePR: false,
+		skipReviewerRequest: false,
 		allowLocalState: false,
 		envNames: [],
 		envFromFiles: false,
@@ -240,6 +262,8 @@ export function parseCursorSdkConfig(value: unknown): CursorSdkConfig | undefine
 		if (branch) parsedCloud.branch = branch;
 		if (isCursorCloudContextHandoff(cloud.contextHandoff)) parsedCloud.contextHandoff = cloud.contextHandoff;
 		if (typeof cloud.directPush === "boolean") parsedCloud.directPush = cloud.directPush;
+		if (typeof cloud.autoCreatePR === "boolean") parsedCloud.autoCreatePR = cloud.autoCreatePR;
+		if (typeof cloud.skipReviewerRequest === "boolean") parsedCloud.skipReviewerRequest = cloud.skipReviewerRequest;
 		if (typeof cloud.allowLocalState === "boolean") parsedCloud.allowLocalState = cloud.allowLocalState;
 		if (envNames) parsedCloud.envNames = envNames;
 		if (typeof cloud.envFromFiles === "boolean") parsedCloud.envFromFiles = cloud.envFromFiles;
@@ -255,6 +279,7 @@ export function parseCursorSdkConfig(value: unknown): CursorSdkConfig | undefine
 		if (typeof local.sandbox === "boolean") parsedLocal.sandbox = local.sandbox;
 		if (typeof local.force === "boolean") parsedLocal.force = local.force;
 		if (typeof local.resume === "boolean") parsedLocal.resume = local.resume;
+		if (typeof local.useHttp1ForAgent === "boolean") parsedLocal.useHttp1ForAgent = local.useHttp1ForAgent;
 		const sandboxOptions = asRecord(local.sandboxOptions);
 		if (typeof sandboxOptions?.enabled === "boolean") parsedLocal.sandboxOptions = { enabled: sandboxOptions.enabled };
 		if (Object.keys(parsedLocal).length > 0) config.local = parsedLocal;
@@ -280,6 +305,25 @@ function readCursorSdkConfigFile(path: string): CursorSdkConfig {
 	}
 }
 
+export function loadCursorSdkConfigForUpdate(path: string): Record<string, unknown> {
+	if (!existsSync(path)) return {};
+	let source: string;
+	try {
+		source = readFileSync(path, "utf-8");
+	} catch (error) {
+		throw new Error(`Failed to read Cursor SDK config ${path}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(source);
+	} catch {
+		throw new Error(`Invalid JSON in Cursor SDK config ${path}`);
+	}
+	const record = asRecord(parsed);
+	if (!record) throw new Error(`Invalid Cursor SDK config ${path}: expected a JSON object`);
+	return record;
+}
+
 export function loadCursorSdkUserConfig(path = getCursorSdkUserConfigPath()): CursorSdkConfig {
 	return readCursorSdkConfigFile(path);
 }
@@ -296,7 +340,39 @@ export function loadCursorSdkConfig(options: LoadCursorSdkConfigOptions = {}): {
 	return project ? { user, project } : { user };
 }
 
-function replaceJsonFile(path: string, config: CursorSdkConfig, mode?: number): void {
+const CONFIG_LOCK_RETRY_MS = 20;
+const CONFIG_LOCK_TIMEOUT_MS = 5_000;
+const configLockWaitBuffer = new Int32Array(new SharedArrayBuffer(4));
+
+function sleepForConfigLock(): void {
+	Atomics.wait(configLockWaitBuffer, 0, 0, CONFIG_LOCK_RETRY_MS);
+}
+
+function acquireCursorSdkConfigLock(path: string): () => void {
+	mkdirSync(dirname(path), { recursive: true });
+	const lockPath = `${path}.lock`;
+	const deadline = Date.now() + CONFIG_LOCK_TIMEOUT_MS;
+	while (true) {
+		try {
+			const descriptor = openSync(lockPath, "wx", 0o600);
+			return () => {
+				try {
+					closeSync(descriptor);
+				} finally {
+					rmSync(lockPath, { force: true });
+				}
+			};
+		} catch (error) {
+			if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
+			if (Date.now() >= deadline) {
+				throw new Error(`Timed out waiting for Cursor SDK config lock ${lockPath}; remove it only if no pi process is writing this config`);
+			}
+			sleepForConfigLock();
+		}
+	}
+}
+
+function replaceJsonFile(path: string, config: object, mode?: number): void {
 	mkdirSync(dirname(path), { recursive: true });
 	const tempPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
 	let replaced = false;
@@ -320,31 +396,61 @@ function replaceJsonFile(path: string, config: CursorSdkConfig, mode?: number):
 	}
 }
 
+function withCursorSdkConfigLock<T>(path: string, operation: () => T): T {
+	const release = acquireCursorSdkConfigLock(path);
+	try {
+		return operation();
+	} finally {
+		release();
+	}
+}
+
+export function updateCursorSdkConfig(
+	path: string,
+	update: (current: Record<string, unknown>) => Record<string, unknown>,
+	options: { newFileMode?: number } = {},
+): Record<string, unknown> {
+	return withCursorSdkConfigLock(path, () => {
+		const updated = update(loadCursorSdkConfigForUpdate(path));
+		const mode = existsSync(path) ? statSync(path).mode & 0o777 : options.newFileMode;
+		replaceJsonFile(path, updated, mode);
+		return updated;
+	});
+}
+
 export function saveCursorSdkUserConfig(config: CursorSdkConfig, path = getCursorSdkUserConfigPath()): void {
-	const mode = existsSync(path) ? statSync(path).mode & 0o777 : 0o600;
-	replaceJsonFile(path, config, mode);
+	updateCursorSdkConfig(path, () => ({ ...config }), { newFileMode: 0o600 });
 }
 
 export function saveCursorSdkProjectConfig(cwd: string, config: CursorSdkConfig, configDirName = CONFIG_DIR_NAME): void {
 	const path = getCursorSdkProjectConfigPath(cwd, configDirName);
-	const mode = existsSync(path) ? statSync(path).mode & 0o777 : undefined;
-	replaceJsonFile(path, config, mode);
+	updateCursorSdkConfig(path, () => ({ ...config }));
 }
 
 export function mergeCursorSdkConfig(base: CursorSdkConfig, patch: CursorSdkConfig): CursorSdkConfig {
+	return mergeCursorSdkConfigForUpdate({ ...base }, patch) as CursorSdkConfig;
+}
+
+export function mergeCursorSdkConfigForUpdate(
+	base: Record<string, unknown>,
+	patch: CursorSdkConfig,
+): Record<string, unknown> {
+	const baseCloud = asRecord(base.cloud);
+	const baseLocal = asRecord(base.local);
+	const baseSandboxOptions = asRecord(baseLocal?.sandboxOptions);
 	return {
 		...base,
 		...patch,
-		...(base.cloud || patch.cloud
-			? { cloud: { ...base.cloud, ...patch.cloud } }
+		...(baseCloud || patch.cloud
+			? { cloud: { ...baseCloud, ...patch.cloud } }
 			: {}),
-		...(base.local || patch.local
+		...(baseLocal || patch.local
 			? {
 					local: {
-						...base.local,
+						...baseLocal,
 						...patch.local,
-						...(base.local?.sandboxOptions || patch.local?.sandboxOptions
-							? { sandboxOptions: { ...base.local?.sandboxOptions, ...patch.local?.sandboxOptions } }
+						...(baseSandboxOptions || patch.local?.sandboxOptions
+							? { sandboxOptions: { ...baseSandboxOptions, ...patch.local?.sandboxOptions } }
 							: {}),
 					},
 				}
@@ -356,7 +462,10 @@ export function cursorFastDefaultsFromConfig(config: CursorSdkConfig | undefined
 	return new Map(Object.entries(config?.fastDefaults ?? {}));
 }
 
-export function withCursorFastDefaults(config: CursorSdkConfig, fastDefaults: Map<string, boolean>): CursorSdkConfig {
+export function withCursorFastDefaults<T extends object>(
+	config: T,
+	fastDefaults: Map<string, boolean>,
+): T & { fastDefaults: Record<string, boolean> } {
 	return {
 		...config,
 		fastDefaults: Object.fromEntries([...fastDefaults.entries()].sort(([a], [b]) => a.localeCompare(b))),
@@ -423,6 +532,7 @@ const RUNTIME_ORDER: CursorFieldSource[] = ["cli", "environment", "session", "pr
 const CLOUD_ORDER: CursorFieldSource[] = ["cli", "environment", "session", "user", "builtin"];
 const LOCAL_ORDER: CursorFieldSource[] = ["cli", "environment", "project", "user", "builtin"];
 const LOCAL_FORCE_ORDER: CursorFieldSource[] = ["cli", "environment", "builtin"];
+const HTTP1_ORDER: CursorFieldSource[] = ["session", "environment", "user", "builtin"];
 
 function buildFieldLayers<T>(order: CursorFieldSource[], values: CursorFieldValues<T>): Array<CursorResolvedSetting<T> | undefined> {
 	return order.map((source) => (source === "builtin" ? resolved("builtin", values.builtin as T) : valueFrom(source, values[source])));
@@ -453,6 +563,8 @@ export function cursorSdkConfigFromEnv(env: Record<string, string | undefined> =
 		'"never", "fresh", or "bootstrap"',
 	);
 	const directPush = parseOptionalEnvBoolean(env[CURSOR_CLOUD_DIRECT_PUSH_ENV]);
+	const autoCreatePR = parseOptionalEnvBoolean(env[CURSOR_CLOUD_AUTO_CREATE_PR_ENV]);
+	const skipReviewerRequest = parseOptionalEnvBoolean(env[CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV]);
 	const allowLocalState = parseOptionalEnvBoolean(env[CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV]);
 	const envNames = parseExplicitCursorCloudEnvNames(env[CURSOR_CLOUD_ENV_ENV], CURSOR_CLOUD_ENV_ENV);
 	const envFromFiles = parseOptionalEnvBoolean(env[CURSOR_CLOUD_ENV_FROM_FILES_ENV]);
@@ -466,6 +578,8 @@ export function cursorSdkConfigFromEnv(env: Record<string, string | undefined> =
 		branch !== undefined ||
 		isCursorCloudContextHandoff(contextHandoff) ||
 		directPush !== undefined ||
+		autoCreatePR !== undefined ||
+		skipReviewerRequest !== undefined ||
 		allowLocalState !== undefined ||
 		envNames !== undefined ||
 		envFromFiles !== undefined ||
@@ -477,6 +591,8 @@ export function cursorSdkConfigFromEnv(env: Record<string, string | undefined> =
 			...(branch !== undefined ? { branch } : {}),
 			...(isCursorCloudContextHandoff(contextHandoff) ? { contextHandoff } : {}),
 			...(directPush !== undefined ? { directPush } : {}),
+			...(autoCreatePR !== undefined ? { autoCreatePR } : {}),
+			...(skipReviewerRequest !== undefined ? { skipReviewerRequest } : {}),
 			...(allowLocalState !== undefined ? { allowLocalState } : {}),
 			...(envNames !== undefined ? { envNames } : {}),
 			...(envFromFiles !== undefined ? { envFromFiles } : {}),
@@ -488,12 +604,14 @@ export function cursorSdkConfigFromEnv(env: Record<string, string | undefined> =
 	const sandbox = parseOptionalEnvBoolean(env[CURSOR_SANDBOX_ENV]);
 	const force = parseOptionalEnvBoolean(env[CURSOR_LOCAL_FORCE_ENV]);
 	const resume = parseOptionalEnvBoolean(env[CURSOR_LOCAL_RESUME_ENV]);
-	if (autoReview !== undefined || sandbox !== undefined || force !== undefined || resume !== undefined) {
+	const useHttp1ForAgent = parseOptionalEnvBoolean(env[CURSOR_HTTP1_ENV]);
+	if (autoReview !== undefined || sandbox !== undefined || force !== undefined || resume !== undefined || useHttp1ForAgent !== undefined) {
 		config.local = {
 			...(autoReview !== undefined ? { autoReview } : {}),
 			...(sandbox !== undefined ? { sandboxOptions: { enabled: sandbox } } : {}),
 			...(force !== undefined ? { force } : {}),
 			...(resume !== undefined ? { resume } : {}),
+			...(useHttp1ForAgent !== undefined ? { useHttp1ForAgent } : {}),
 		};
 	}
 	return config;
@@ -567,6 +685,28 @@ export function resolveCursorSdkConfig(options: ResolveCursorSdkConfigOptions =
 				},
 				(value) => (value ? 1 : 0),
 			),
+			autoCreatePR: resolveSafetyField(
+				CLOUD_ORDER,
+				{
+					cli: cli?.cloud?.autoCreatePR,
+					environment: env.cloud?.autoCreatePR,
+					session: session?.cloud?.autoCreatePR,
+					user: user?.cloud?.autoCreatePR,
+					builtin: builtIn.cloud.autoCreatePR,
+				},
+				(value) => (value ? 1 : 0),
+			),
+			skipReviewerRequest: resolveSafetyField(
+				CLOUD_ORDER,
+				{
+					cli: cli?.cloud?.skipReviewerRequest,
+					environment: env.cloud?.skipReviewerRequest,
+					session: session?.cloud?.skipReviewerRequest,
+					user: user?.cloud?.skipReviewerRequest,
+					builtin: builtIn.cloud.skipReviewerRequest,
+				},
+				(value) => (value ? 1 : 0),
+			),
 			allowLocalState: resolveSafetyField(
 				CLOUD_ORDER,
 				{
@@ -638,6 +778,12 @@ export function resolveCursorSdkConfig(options: ResolveCursorSdkConfigOptions =
 				user: user?.local?.resume,
 				builtin: true,
 			}),
+			useHttp1ForAgent: resolveOrdinaryField(HTTP1_ORDER, {
+				session: session?.local?.useHttp1ForAgent,
+				environment: env.local?.useHttp1ForAgent,
+				user: user?.local?.useHttp1ForAgent,
+				builtin: false,
+			}),
 		},
 	};
 }

package/src/cursor-http1.ts

@@ -0,0 +1,65 @@
+import type { CursorSdkModule } from "./cursor-sdk-runtime.js";
+import type { CursorResolvedSetting } from "./cursor-config.js";
+import { asRecord } from "./cursor-record-utils.js";
+
+export const CURSOR_HTTP1_ENTRY_TYPE = "cursor-http1-state";
+
+export interface CursorHttp1EntryData {
+	enabled: boolean;
+}
+
+type CursorHttp1Sdk = {
+	Cursor: Pick<CursorSdkModule["Cursor"], "configure">;
+};
+
+let sessionCursorHttp1Enabled: boolean | undefined;
+let globalPreferenceAuthoritative = false;
+let configuredCursor: CursorHttp1Sdk["Cursor"] | undefined;
+
+export function isCursorHttp1EntryData(value: unknown): value is CursorHttp1EntryData {
+	return typeof asRecord(value)?.enabled === "boolean";
+}
+
+export function getStoredCursorHttp1Enabled(): boolean | undefined {
+	return sessionCursorHttp1Enabled;
+}
+
+export function setStoredCursorHttp1Enabled(enabled: boolean | undefined): void {
+	sessionCursorHttp1Enabled = enabled;
+}
+
+export function getResolvedSessionCursorHttp1Enabled(): boolean | undefined {
+	return globalPreferenceAuthoritative ? undefined : sessionCursorHttp1Enabled;
+}
+
+export function setCursorHttp1GlobalPreferenceAuthoritative(authoritative: boolean): void {
+	globalPreferenceAuthoritative = authoritative;
+}
+
+export function clearCursorSdkHttp1(): void {
+	if (configuredCursor === undefined) return;
+	configuredCursor.configure({ local: { useHttp1ForAgent: null } });
+	configuredCursor = undefined;
+}
+
+export function configureCursorSdkHttp1(
+	sdk: CursorHttp1Sdk,
+	setting: CursorResolvedSetting<boolean>,
+): boolean | undefined {
+	if (setting.source !== "builtin") {
+		sdk.Cursor.configure({ local: { useHttp1ForAgent: setting.value } });
+		configuredCursor = sdk.Cursor;
+		return setting.value;
+	}
+	if (configuredCursor === sdk.Cursor) clearCursorSdkHttp1();
+	else configuredCursor = undefined;
+	return undefined;
+}
+
+export const __testUtils = {
+	reset(): void {
+		sessionCursorHttp1Enabled = undefined;
+		globalPreferenceAuthoritative = false;
+		configuredCursor = undefined;
+	},
+};

package/src/cursor-live-run-coordinator.ts

@@ -105,6 +105,11 @@ export interface CursorLiveRunCoordinator {
 
 type CursorLiveBridgeMatcher = Pick<CursorPiToolBridgeRun, "hasPendingPiToolCallId">;
 
+function isPendingBridgeToolRequest(run: CursorLiveRun, request: CursorPiBridgeToolRequest): boolean {
+	const bridgeRun = [run.bridgeRun, run.sessionBridgeRun].find((candidate) => candidate?.id === request.runId);
+	return bridgeRun?.hasPendingPiToolCallId(request.piToolCallId) === true;
+}
+
 export interface CursorLiveRunRecord {
 	id: string;
 	disposed: boolean;
@@ -384,7 +389,9 @@ export function createCursorLiveRunCoordinator(deps: CursorLiveRunCoordinatorDep
 			const requests: CursorPiBridgeToolRequest[] = [];
 			while (run.pendingEvents[0]?.type === "bridge-tool") {
 				const event = run.pendingEvents.shift();
-				if (event?.type === "bridge-tool") requests.push(event.request);
+				if (event?.type === "bridge-tool" && isPendingBridgeToolRequest(run, event.request)) {
+					requests.push(event.request);
+				}
 			}
 			return requests;
 		},

package/src/cursor-pi-tool-bridge-abort.ts

@@ -54,11 +54,18 @@ class CursorPiToolBridgeToolExecutionAbortTracker {
 		for (const toolCallId of [...this.activeExecutions.keys()]) this.finish(toolCallId);
 	}
 
+	abort(toolCallId: string, reason: string): boolean {
+		const execution = this.activeExecutions.get(toolCallId);
+		if (!execution) return false;
+		this.cancelExecution(execution, reason);
+		this.abortExecution(execution);
+		this.finish(toolCallId);
+		return true;
+	}
+
 	abortAll(reason: string): void {
 		for (const execution of [...this.activeExecutions.values()]) {
-			this.cancelExecution(execution, reason);
-			this.abortExecution(execution);
-			this.finish(execution.toolCallId);
+			this.abort(execution.toolCallId, reason);
 		}
 	}
 

package/src/cursor-pi-tool-bridge-constants.ts

@@ -1,2 +1,8 @@
 export const MCP_SERVER_NAME = "pi_tools";
 export const MCP_ENDPOINT_ROOT = "/cursor-pi-tool-bridge";
+
+const CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN = /^cursor-pi-bridge-run-[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}-tool-\d+$/i;
+
+export function isCursorPiBridgeToolCallId(toolCallId: string): boolean {
+	return CURSOR_PI_BRIDGE_TOOL_CALL_ID_PATTERN.test(toolCallId);
+}

package/src/cursor-pi-tool-bridge-env.ts

@@ -1,7 +1,9 @@
 import { parseEnvBoolean } from "./cursor-env-boolean.js";
+import { resolveCursorMcpToolTimeoutMs } from "./cursor-mcp-timeout-override.js";
 
 export const CURSOR_PI_TOOL_BRIDGE_ENV = "PI_CURSOR_PI_TOOL_BRIDGE";
 export const CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV = "PI_CURSOR_EXPOSE_BUILTIN_TOOLS";
+export const CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV = "PI_CURSOR_PI_BRIDGE_CALL_TIMEOUT_MS";
 
 export function resolveCursorPiToolBridgeEnabled(env: Record<string, string | undefined> = process.env): boolean {
 	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_ENV], true);
@@ -10,3 +12,10 @@ export function resolveCursorPiToolBridgeEnabled(env: Record<string, string | un
 export function resolveCursorPiToolBridgeBuiltinsEnabled(env: Record<string, string | undefined> = process.env): boolean {
 	return parseEnvBoolean(env[CURSOR_PI_TOOL_BRIDGE_BUILTINS_ENV], false);
 }
+
+export function resolveCursorPiToolBridgeCallTimeoutMs(env: Record<string, string | undefined> = process.env): number {
+	const mcpToolTimeoutMs = resolveCursorMcpToolTimeoutMs(env);
+	const parsed = Number(env[CURSOR_PI_TOOL_BRIDGE_CALL_TIMEOUT_MS_ENV]?.trim());
+	if (!Number.isFinite(parsed) || parsed <= 0) return mcpToolTimeoutMs;
+	return Math.min(Math.max(Math.trunc(parsed), 1), mcpToolTimeoutMs);
+}