@emmaneugene/pi-cursor-sdk 0.3.7 → 0.4.1

package/src/cursor-runtime-state.ts

@@ -1,106 +1,38 @@
-import type { ExtensionAPI, ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-import {
-	registerCursorCloudLifecycleLedger,
-	runCursorCloudLifecycleCommand,
-} from "./cursor-cloud-lifecycle.js";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import {
 	CURSOR_AUTO_REVIEW_ENV,
-	CURSOR_CLOUD_ACK_ENV,
-	CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV,
-	CURSOR_CLOUD_AUTO_CREATE_PR_ENV,
-	CURSOR_CLOUD_BRANCH_ENV,
-	CURSOR_CLOUD_CONTEXT_ENV,
-	CURSOR_CLOUD_DIRECT_PUSH_ENV,
-	CURSOR_CLOUD_ENV_ENV,
-	CURSOR_CLOUD_ENV_FROM_FILES_ENV,
-	CURSOR_CLOUD_ENV_NAME_ENV,
-	CURSOR_CLOUD_ENV_TYPE_ENV,
-	CURSOR_CLOUD_REPO_ENV,
-	CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV,
 	CURSOR_LOCAL_FORCE_ENV,
 	CURSOR_LOCAL_RESUME_ENV,
-	CURSOR_RUNTIME_ENV,
 	CURSOR_SANDBOX_ENV,
-	getCursorSdkProjectConfigPath,
-	getCursorSdkUserConfigPath,
 	loadCursorSdkConfig,
-	mergeCursorSdkConfigForUpdate,
-	parseExplicitCursorCloudEnvNames,
 	resolveCursorSdkConfig,
-	updateCursorSdkConfig,
 	type CursorExplicitSdkConfig,
 	type CursorResolvedSdkConfig,
 	type CursorResolvedSetting,
-	type CursorRuntime,
 	type CursorSdkConfig,
 } from "./cursor-config.js";
-import { asRecord } from "./cursor-record-utils.js";
 import { getResolvedSessionCursorHttp1Enabled } from "./cursor-http1.js";
 import { getCursorSessionCwd, getCursorSessionProjectTrusted } from "./cursor-session-scope.js";
 
-export const CURSOR_RUNTIME_ENTRY_TYPE = "cursor-runtime-state";
-
-export const CURSOR_CLOUD_ACK_DISCLOSURE = [
-	"Cursor Cloud executes this work remotely.",
-	"Fresh context is used by default; prior Pi context is included only with explicit bootstrap opt-in.",
-	"Pi-local tools and the Pi bridge are unavailable, and Pi environment variables are not forwarded.",
-	"Cursor may create branches, commit, push, and open pull requests.",
-	"Cloud agents remain until you archive or delete them.",
-	"Cloud Agents run in Max Mode, are billed at Cursor API pricing, and may require spend-limit setup.",
-].join("\n\n");
-
-interface CursorRuntimeEntryData {
-	runtime: CursorRuntime;
-	cloudAcknowledged?: boolean;
-}
-
-export type CursorRuntimeStateExtensionApi = Pick<
-	ExtensionAPI,
-	"appendEntry" | "getFlag" | "registerFlag" | "registerCommand" | "on"
->;
+export type CursorRuntimeStateExtensionApi = Pick<ExtensionAPI, "getFlag" | "registerFlag">;
 
 type CursorRuntimeContext = Pick<ExtensionContext, "cwd">;
 
-type CursorStatusRefresh = (ctx: ExtensionContext) => void;
-
 interface CursorCliConfigSnapshot {
 	config: CursorExplicitSdkConfig;
-	cloudEnvNames?: string;
 }
 
 let cliCursorSnapshot: CursorCliConfigSnapshot = { config: {} };
 let cliLocalForceConsumed = false;
 let envLocalForceConsumed = false;
-let sessionCursorRuntime: CursorRuntime | undefined;
-let sessionCursorCloudAcknowledged = false;
-
-function isCursorRuntimeEntryData(value: unknown): value is CursorRuntimeEntryData {
-	const record = asRecord(value);
-	if (!record) return false;
-	return (record.runtime === "local" || record.runtime === "cloud")
-		&& (record.cloudAcknowledged === undefined || typeof record.cloudAcknowledged === "boolean");
-}
-
-function stringFlagValue(value: boolean | string | undefined): string | undefined {
-	return typeof value === "string" && value.trim() ? value.trim() : undefined;
-}
 
 export function getCursorCliConfig(): CursorExplicitSdkConfig {
-	const config = structuredClone(cliCursorSnapshot.config);
-	const envNames = parseExplicitCursorCloudEnvNames(cliCursorSnapshot.cloudEnvNames, "--cursor-cloud-env");
-	if (envNames) config.cloud = { ...config.cloud, envNames };
-	return config;
+	return structuredClone(cliCursorSnapshot.config);
 }
 
 export function getCursorSessionConfig(): CursorSdkConfig {
 	const useHttp1ForAgent = getResolvedSessionCursorHttp1Enabled();
 	return {
-		...(sessionCursorRuntime
-			? {
-					runtime: sessionCursorRuntime,
-					...(sessionCursorCloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-				}
-			: {}),
 		...(useHttp1ForAgent === undefined ? {} : { local: { useHttp1ForAgent } }),
 	};
 }
@@ -128,7 +60,6 @@ export function resolveEffectiveCursorConfigForContext(ctx: CursorRuntimeContext
 export type CursorRuntimeResolution =
 	| {
 			kind: "valid";
-			runtime: CursorResolvedSetting<CursorRuntime>;
 			useHttp1ForAgent: CursorResolvedSetting<boolean>;
 		}
 	| { kind: "invalid"; message: string };
@@ -138,7 +69,6 @@ export function resolveCursorStatusRuntime(ctx: CursorRuntimeContext): CursorRun
 		const config = resolveEffectiveCursorConfigForContext(ctx);
 		return {
 			kind: "valid",
-			runtime: config.runtime,
 			useHttp1ForAgent: config.local.useHttp1ForAgent,
 		};
 	} catch (error) {
@@ -146,21 +76,13 @@ export function resolveCursorStatusRuntime(ctx: CursorRuntimeContext): CursorRun
 	}
 }
 
-export function formatResolvedCursorRuntime(runtime: CursorResolvedSetting<CursorRuntime>): string {
-	const cap = runtime.cappedBy;
-	return cap
-		? `${runtime.value} (source: ${runtime.source} safety cap over ${cap.cappedSource} ${cap.cappedValue})`
-		: `${runtime.value} (source: ${runtime.source})`;
-}
-
 export function formatCursorStatus(
-	runtime: CursorRuntime | "invalid",
 	fast: boolean | undefined,
 	mode: "agent" | "plan" | "invalid",
 	useHttp1ForAgent = false,
 ): string {
-	const parts = [`cursor:${runtime}`, fast === true ? "fast:on" : fast === false ? "fast:off" : "fast:n/a"];
-	if (runtime === "local" && useHttp1ForAgent) parts.push("http1");
+	const parts = ["cursor", fast === true ? "fast:on" : fast === false ? "fast:off" : "fast:n/a"];
+	if (useHttp1ForAgent) parts.push("http1");
 	if (mode === "invalid") parts.push("mode invalid");
 	else if (mode === "plan") parts.push("plan");
 	return parts.join(" · ");
@@ -183,40 +105,7 @@ export function consumeCursorLocalForceOverride(resolved: { value: boolean; sour
 	return false;
 }
 
-export function restoreSessionCursorRuntimeState(branch: readonly SessionEntry[]): void {
-	sessionCursorRuntime = undefined;
-	sessionCursorCloudAcknowledged = false;
-	for (const entry of branch) {
-		if (entry.type !== "custom" || entry.customType !== CURSOR_RUNTIME_ENTRY_TYPE) continue;
-		if (isCursorRuntimeEntryData(entry.data)) {
-			sessionCursorRuntime = entry.data.runtime;
-			sessionCursorCloudAcknowledged ||= entry.data.cloudAcknowledged === true;
-		}
-	}
-}
-
 export function restoreCursorCliState(pi: Pick<ExtensionAPI, "getFlag">): void {
-	const runtime = stringFlagValue(pi.getFlag("cursor-runtime"));
-	const repo = stringFlagValue(pi.getFlag("cursor-cloud-repo"));
-	const branch = stringFlagValue(pi.getFlag("cursor-cloud-branch"));
-	const contextHandoff = stringFlagValue(pi.getFlag("cursor-cloud-context"));
-	const environmentType = stringFlagValue(pi.getFlag("cursor-cloud-env-type"));
-	const environmentName = stringFlagValue(pi.getFlag("cursor-cloud-env-name"));
-	const cloudEnvNames = stringFlagValue(pi.getFlag("cursor-cloud-env"));
-	const cloud: NonNullable<CursorExplicitSdkConfig["cloud"]> = {
-		...(repo ? { repo } : {}),
-		...(branch ? { branch } : {}),
-		...(contextHandoff ? { contextHandoff } : {}),
-		...(pi.getFlag("cursor-cloud-direct-push") === true ? { directPush: true } : {}),
-		...(pi.getFlag("cursor-cloud-auto-create-pr") === true ? { autoCreatePR: true } : {}),
-		...(pi.getFlag("cursor-cloud-skip-reviewer-request") === true ? { skipReviewerRequest: true } : {}),
-		...(pi.getFlag("cursor-cloud-allow-local-state") === true ? { allowLocalState: true } : {}),
-		...(pi.getFlag("cursor-cloud-env-from-files") === true ? { envFromFiles: true } : {}),
-		...(environmentType || environmentName
-			? { environment: { ...(environmentType ? { type: environmentType } : {}), ...(environmentName ? { name: environmentName } : {}) } }
-			: {}),
-		...(pi.getFlag("cursor-cloud-ack") === true ? { acknowledged: true } : {}),
-	};
 	const local: NonNullable<CursorExplicitSdkConfig["local"]> = {
 		...(pi.getFlag("cursor-auto-review") === true ? { autoReview: true } : {}),
 		...(pi.getFlag("cursor-sandbox") === true ? { sandboxOptions: { enabled: true } } : {}),
@@ -229,94 +118,12 @@ export function restoreCursorCliState(pi: Pick<ExtensionAPI, "getFlag">): void {
 	};
 	cliCursorSnapshot = {
 		config: {
-			...(runtime ? { runtime } : {}),
-			...(Object.keys(cloud).length ? { cloud } : {}),
 			...(Object.keys(local).length ? { local } : {}),
 		},
-		...(cloudEnvNames ? { cloudEnvNames } : {}),
 	};
 }
 
-function persistCursorRuntimePreference(
-	pi: Pick<ExtensionAPI, "appendEntry">,
-	runtime: CursorRuntime,
-	cloudAcknowledged = false,
-): void {
-	const acknowledged = sessionCursorCloudAcknowledged || cloudAcknowledged;
-	pi.appendEntry<CursorRuntimeEntryData>(CURSOR_RUNTIME_ENTRY_TYPE, {
-		runtime,
-		...(acknowledged ? { cloudAcknowledged: true } : {}),
-	});
-	sessionCursorRuntime = runtime;
-	sessionCursorCloudAcknowledged = acknowledged;
-}
-
-function registerCursorRuntimeFlags(pi: Pick<ExtensionAPI, "registerFlag">): void {
-	pi.registerFlag("cursor-runtime", {
-		description: `Select Cursor runtime for this run: local or cloud (or set ${CURSOR_RUNTIME_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-repo", {
-		description: `Set Cursor cloud repository URL for this run (or set ${CURSOR_CLOUD_REPO_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-branch", {
-		description: `Set Cursor cloud branch/ref for this run (or set ${CURSOR_CLOUD_BRANCH_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-context", {
-		description: `Set Cursor cloud context handoff: never, fresh, or bootstrap (or set ${CURSOR_CLOUD_CONTEXT_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-direct-push", {
-		description: `Allow Cursor cloud direct push for this run (or set ${CURSOR_CLOUD_DIRECT_PUSH_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
-	pi.registerFlag("cursor-cloud-auto-create-pr", {
-		description: `Ask Cursor cloud to create a pull request for this run (or set ${CURSOR_CLOUD_AUTO_CREATE_PR_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
-	pi.registerFlag("cursor-cloud-skip-reviewer-request", {
-		description: `Ask Cursor cloud not to request you as a reviewer for this run (or set ${CURSOR_CLOUD_SKIP_REVIEWER_REQUEST_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
-	pi.registerFlag("cursor-cloud-allow-local-state", {
-		description: `Allow Cursor cloud to proceed with local-only state for this run (or set ${CURSOR_CLOUD_ALLOW_LOCAL_STATE_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
-	pi.registerFlag("cursor-cloud-env", {
-		description: `Reserved Cursor cloud env var names; env forwarding is not implemented yet (or set ${CURSOR_CLOUD_ENV_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-env-from-files", {
-		description: `Reserved Cursor cloud env-file forwarding flag; not implemented yet (or set ${CURSOR_CLOUD_ENV_FROM_FILES_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
-	pi.registerFlag("cursor-cloud-env-type", {
-		description: `Select Cursor-managed cloud environment type: cloud, pool, or machine (or set ${CURSOR_CLOUD_ENV_TYPE_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-env-name", {
-		description: `Select Cursor-managed cloud environment name (or set ${CURSOR_CLOUD_ENV_NAME_ENV})`,
-		type: "string",
-		default: "",
-	});
-	pi.registerFlag("cursor-cloud-ack", {
-		description: `Acknowledge first-use Cursor cloud runtime risks for this run (or set ${CURSOR_CLOUD_ACK_ENV}=1)`,
-		type: "boolean",
-		default: false,
-	});
+export function registerCursorLocalRuntimeFlags(pi: Pick<ExtensionAPI, "registerFlag">): void {
 	pi.registerFlag("cursor-auto-review", {
 		description: `Enable Cursor SDK local Auto-review for this run (or set ${CURSOR_AUTO_REVIEW_ENV}=1)`,
 		type: "boolean",
@@ -344,154 +151,8 @@ function registerCursorRuntimeFlags(pi: Pick<ExtensionAPI, "registerFlag">): voi
 	});
 }
 
-async function confirmCloudAcknowledgement(
-	ctx: Pick<ExtensionContext, "hasUI" | "ui">,
-	alreadyAcknowledged: boolean,
-): Promise<boolean> {
-	if (alreadyAcknowledged) return true;
-	if (!ctx.hasUI) {
-		ctx.ui.notify(
-			`Cursor cloud runtime requires first-use acknowledgement. Pass --cursor-cloud-ack or set ${CURSOR_CLOUD_ACK_ENV}=1, then retry.`,
-			"error",
-		);
-		return false;
-	}
-	const confirmed = await ctx.ui.confirm("Enable Cursor Cloud runtime?", CURSOR_CLOUD_ACK_DISCLOSURE);
-	if (!confirmed) ctx.ui.notify("Cursor cloud runtime change cancelled; no settings were written.", "info");
-	return confirmed;
-}
-
-function registerCursorRuntimeCommand(
-	pi: Pick<ExtensionAPI, "appendEntry" | "registerCommand">,
-	refreshStatus: CursorStatusRefresh,
-): void {
-	pi.registerCommand("cursor-runtime", {
-		description: "Set Cursor runtime for this session: local or cloud",
-		handler: async (args, ctx) => {
-			const usage = "Usage: /cursor-runtime local|cloud [--save-user|--save-project]";
-			const tokens = args.trim().split(/\s+/).filter(Boolean);
-			const raw = tokens[0];
-			const saveUser = tokens.includes("--save-user");
-			const saveProject = tokens.includes("--save-project");
-			const extra = tokens.slice(1).filter((token) => token !== "--save-user" && token !== "--save-project");
-			const currentResolution = resolveCursorStatusRuntime(ctx);
-			if (!raw) {
-				ctx.ui.notify(
-					currentResolution.kind === "invalid"
-						? `${currentResolution.message} ${usage}`
-						: `Cursor runtime is ${formatResolvedCursorRuntime(currentResolution.runtime)}. ${usage}`,
-					currentResolution.kind === "invalid" ? "error" : "info",
-				);
-				return;
-			}
-			if ((raw !== "local" && raw !== "cloud") || extra.length > 0 || (saveUser && saveProject)) {
-				ctx.ui.notify(`Invalid Cursor runtime arguments. ${usage}`, "error");
-				return;
-			}
-			if (currentResolution.kind === "invalid") {
-				ctx.ui.notify(`${currentResolution.message} Fix the explicit override before changing the session runtime.`, "error");
-				return;
-			}
-			if (saveProject && (getCursorSessionCwd() !== ctx.cwd || !getCursorSessionProjectTrusted())) {
-				ctx.ui.notify(
-					"Cannot save Cursor project config without explicit project-trust provenance. Ensure .pi/settings.json or another Pi project resource exists, trust the project, then restart pi; or restart with --approve. Project-local package installs must use --approve on every run that reads or writes .pi/cursor-sdk.json.",
-					"error",
-				);
-				return;
-			}
-			const cloudAcknowledged = raw === "cloud" && await confirmCloudAcknowledgement(
-				ctx,
-				resolveEffectiveCursorConfigForContext(ctx).cloud.acknowledged.value,
-			);
-			if (raw === "cloud" && !cloudAcknowledged) return;
-			if (saveUser || saveProject) {
-				try {
-					if (saveUser) {
-						updateCursorSdkConfig(
-							getCursorSdkUserConfigPath(),
-							(current) => mergeCursorSdkConfigForUpdate(current, {
-								runtime: raw,
-								...(cloudAcknowledged ? { cloud: { acknowledged: true } } : {}),
-							}),
-							{ newFileMode: 0o600 },
-						);
-					} else {
-						updateCursorSdkConfig(
-							getCursorSdkProjectConfigPath(ctx.cwd),
-							(current) => mergeCursorSdkConfigForUpdate(current, { runtime: raw }),
-						);
-					}
-				} catch (error) {
-					const effectiveResolution = resolveCursorStatusRuntime(ctx);
-					refreshStatus(ctx);
-					const effective = effectiveResolution.kind === "valid"
-						? ` Effective runtime remains ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-						: ` ${effectiveResolution.message}`;
-					ctx.ui.notify(
-						`Failed to save Cursor runtime preference to ${saveUser ? "user" : "project"} config: ${error instanceof Error ? error.message : String(error)}.${effective}`,
-						"error",
-					);
-					return;
-				}
-			}
-			try {
-				persistCursorRuntimePreference(pi, raw, cloudAcknowledged);
-			} catch (error) {
-				const effectiveResolution = resolveCursorStatusRuntime(ctx);
-				refreshStatus(ctx);
-				const effective = effectiveResolution.kind === "valid"
-					? ` Effective runtime is ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-					: ` ${effectiveResolution.message}`;
-				const persisted = saveUser
-					? "User config was saved, but persisting the session runtime entry failed."
-					: saveProject
-						? "Project config was saved, but persisting the session runtime entry failed."
-						: "Persisting the session runtime entry failed.";
-				ctx.ui.notify(
-					`${persisted} ${error instanceof Error ? error.message : String(error)}.${effective}`,
-					"error",
-				);
-				return;
-			}
-			const effectiveResolution = resolveCursorStatusRuntime(ctx);
-			refreshStatus(ctx);
-			const saved = saveUser
-				? " Saved to user config."
-				: saveProject
-					? " Saved to project config; cloud acknowledgement remains session/user-scoped."
-					: "";
-			const effective = effectiveResolution.kind === "valid"
-				? ` Effective runtime is ${formatResolvedCursorRuntime(effectiveResolution.runtime)}.`
-				: ` ${effectiveResolution.message}`;
-			ctx.ui.notify(
-				raw === "cloud"
-					? `Cursor runtime request saved for this session and cloud risk acknowledged.${effective}${saved}`
-					: `Cursor runtime request saved for this session.${effective}${saved}`,
-				"info",
-			);
-		},
-	});
-}
-
-export function registerCursorCloudRuntimeControls(
-	pi: CursorRuntimeStateExtensionApi,
-	options: { refreshStatus: CursorStatusRefresh },
-): void {
-	registerCursorCloudLifecycleLedger(pi);
-	registerCursorRuntimeFlags(pi);
-	registerCursorRuntimeCommand(pi, options.refreshStatus);
-	pi.registerCommand("cursor-cloud", {
-		description: "List, archive, or delete recorded Cursor cloud agents for this session branch",
-		handler: async (args, ctx) => {
-			await runCursorCloudLifecycleCommand(pi, args, ctx);
-		},
-	});
-}
-
 export function resetCursorRuntimeStateForTests(): void {
 	cliCursorSnapshot = { config: {} };
 	cliLocalForceConsumed = false;
 	envLocalForceConsumed = false;
-	sessionCursorRuntime = undefined;
-	sessionCursorCloudAcknowledged = false;
 }

package/src/cursor-sdk-billed-usage.ts

@@ -1,5 +1,4 @@
 import type { SDKAgent } from "@cursor/sdk";
-import type { CursorRuntime } from "./cursor-config.js";
 import { asRecord, getArray, getString } from "./cursor-record-utils.js";
 import { readCursorSdkTurnUsage, type CursorSdkTurnUsage } from "./cursor-usage-accounting.js";
 
@@ -9,10 +8,6 @@ const BILLED_USAGE_TIMEOUT_MS = 5000;
 // Upgrade to session-scoped storage if multi-day processes retain enough agent IDs to matter.
 const seenBilledRunIdsByAgent = new Map<string, Set<string>>();
 
-export function isCursorSdkClientMintedRunId(runId: string): boolean {
-	return runId.startsWith("run-");
-}
-
 export function sumCursorSdkTurnUsage(usages: readonly CursorSdkTurnUsage[]): CursorSdkTurnUsage | undefined {
 	if (usages.length === 0) return undefined;
 	return usages.reduce(
@@ -52,7 +47,7 @@ function withTimeout<T>(promise: Promise<T>, timeoutMs = BILLED_USAGE_TIMEOUT_MS
 
 export function selectCursorBilledTurnUsage(
 	agentUsage: unknown,
-	options: { runtime: CursorRuntime; runId?: string; seenRunIds?: ReadonlySet<string> },
+	options: { seenRunIds?: ReadonlySet<string> },
 ): { turn?: CursorSdkTurnUsage; runIds: string[] } {
 	const runs = (getArray(asRecord(agentUsage), "runs") ?? []).flatMap((item) => {
 		const record = asRecord(item);
@@ -60,40 +55,24 @@ export function selectCursorBilledTurnUsage(
 		const usage = readCursorSdkTurnUsage(record?.usage);
 		return runId && usage ? [{ runId, usage }] : [];
 	});
-	if (options.runtime === "cloud" && options.runId) {
-		const match = runs.find((run) => run.runId === options.runId);
-		return match ? { turn: match.usage, runIds: [match.runId] } : { runIds: [] };
-	}
 	const unseen = runs.filter((run) => !options.seenRunIds?.has(run.runId));
 	return { turn: sumCursorSdkTurnUsage(unseen.map((run) => run.usage)), runIds: unseen.map((run) => run.runId) };
 }
 
 export async function fetchCursorSdkAgentUsage(
 	agent: SDKAgent,
-	options: { runtime: CursorRuntime; runId?: string },
 ): Promise<unknown | undefined> {
 	if (typeof agent.getUsage !== "function") return undefined;
-	const query =
-		options.runtime === "cloud" && options.runId && isCursorSdkClientMintedRunId(options.runId)
-			? { runId: options.runId }
-			: undefined;
-	return withTimeout(Promise.resolve(agent.getUsage(query)));
+	return withTimeout(Promise.resolve(agent.getUsage()));
 }
 
 export async function attachCursorSdkBilledTurnUsage(options: {
 	agent: SDKAgent;
 	agentId: string;
-	runtime: CursorRuntime;
-	runId?: string;
 }): Promise<{ agentUsage?: unknown; turn?: CursorSdkTurnUsage }> {
-	const agentUsage = await fetchCursorSdkAgentUsage(options.agent, {
-		runtime: options.runtime,
-		runId: options.runId,
-	});
+	const agentUsage = await fetchCursorSdkAgentUsage(options.agent);
 	if (!agentUsage) return {};
 	const selected = selectCursorBilledTurnUsage(agentUsage, {
-		runtime: options.runtime,
-		runId: options.runtime === "cloud" ? options.runId : undefined,
 		seenRunIds: peekCursorBilledUsageRunIds(options.agentId),
 	});
 	rememberCursorBilledUsageRunIds(options.agentId, selected.runIds);

package/src/cursor-sdk-platform-package.ts

@@ -0,0 +1,106 @@
+import { accessSync, constants, existsSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join } from "node:path";
+
+const RIPGREP_ENV = "CURSOR_RIPGREP_PATH";
+const TREE_SITTER_VENDOR_ENV = "CURSOR_TREE_SITTER_VENDOR_DIR";
+
+function cursorSdkPlatformPackageName(): string {
+	return `@cursor/sdk-${process.platform}-${process.arch}`;
+}
+
+function resolveCursorSdkPlatformPackageDir(
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	try {
+		const require = createRequire(fromModuleUrl);
+		const sdkEntry = require.resolve("@cursor/sdk");
+		return dirname(
+			require.resolve(`${cursorSdkPlatformPackageName()}/package.json`, {
+				paths: [dirname(sdkEntry)],
+			}),
+		);
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveCursorSdkPlatformBinary(
+	binaryName: string,
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	try {
+		const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+		if (!packageDirectory) return undefined;
+		const binaryPath = join(packageDirectory, "bin", binaryName);
+		accessSync(binaryPath, constants.X_OK);
+		return binaryPath;
+	} catch {
+		return undefined;
+	}
+}
+
+export function resolveBundledCursorRipgrepPath(
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	return resolveCursorSdkPlatformBinary(process.platform === "win32" ? "rg.exe" : "rg", fromModuleUrl);
+}
+
+export function ensureCursorRipgrepPath(): string | undefined {
+	const configuredPath = process.env[RIPGREP_ENV];
+	if (configuredPath && isAbsolute(configuredPath)) return configuredPath;
+
+	const bundledPath = resolveBundledCursorRipgrepPath();
+	if (bundledPath) process.env[RIPGREP_ENV] = bundledPath;
+	return bundledPath;
+}
+
+export function resolveBundledCursorTreeSitterVendorDir(
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+	if (!packageDirectory) return undefined;
+	const vendorDir = join(packageDirectory, "vendor");
+	if (!existsSync(join(vendorDir, "tree-sitter", "index.js"))) return undefined;
+	return vendorDir;
+}
+
+export function ensureCursorTreeSitterVendorDir(): string | undefined {
+	const configuredPath = process.env[TREE_SITTER_VENDOR_ENV];
+	if (configuredPath && isAbsolute(configuredPath)) return configuredPath;
+
+	const bundledPath = resolveBundledCursorTreeSitterVendorDir();
+	if (bundledPath) process.env[TREE_SITTER_VENDOR_ENV] = bundledPath;
+	return bundledPath;
+}
+
+export function resolveBundledCursorSandboxPath(
+	fromModuleUrl: string | URL = import.meta.url,
+): string | undefined {
+	return resolveCursorSdkPlatformBinary(
+		process.platform === "win32" ? "cursorsandbox.exe" : "cursorsandbox",
+		fromModuleUrl,
+	);
+}
+
+/**
+ * The SDK finds `cursorsandbox` by walking from `process.argv[1]`, not from
+ * `require.resolve`. Point that walk at the installed platform package for the
+ * duration of local `Agent.create` / `Agent.resume`.
+ */
+export async function runWithCursorSdkPlatformPackageVisible<T>(
+	run: () => Promise<T>,
+	fromModuleUrl: string | URL = import.meta.url,
+): Promise<T> {
+	const packageDirectory = resolveCursorSdkPlatformPackageDir(fromModuleUrl);
+	if (!packageDirectory) return run();
+	const hostEntry = join(packageDirectory, "package.json");
+	if (!existsSync(hostEntry)) return run();
+	const previousArgv1 = process.argv[1];
+	process.argv[1] = hostEntry;
+	try {
+		return await run();
+	} finally {
+		if (process.argv[1] === hostEntry) process.argv[1] = previousArgv1;
+	}
+}

package/src/cursor-session-agent.ts

@@ -14,6 +14,7 @@ import {
 } from "./cursor-session-agent-resume.js";
 import type { CursorSdkEventDebugRecorder } from "./cursor-sdk-event-debug.js";
 import { loadCursorSdk, type CursorSdkModule } from "./cursor-sdk-runtime.js";
+import { runWithCursorSdkPlatformPackageVisible } from "./cursor-sdk-platform-package.js";
 import {
 	cursorSessionStoreIdentitiesEqual,
 	openCursorSessionStore,
@@ -501,20 +502,23 @@ async function createSessionAgentEntry(
 		let agent: SDKAgent | undefined;
 		let effectiveSendState = sendState;
 		let resumed = false;
-		if (resumeHandle && resumeAttemptAllowed && resumeAgent) {
-			try {
-				agent = await resumeAgent(resumeHandle.agentId, buildAgentOptions());
-				effectiveSendState = { ...resumeHandle.sendState };
-				resumed = true;
-			} catch {
-				if (persistentStore) resumeNotice = LOCAL_RESUME_FALLBACK_NOTICE;
-				if (!cursorSessionStoreIdentitiesEqual(sessionStore.identity, identities.sessionStore)) {
-					await sessionStore.dispose().catch(() => undefined);
-					sessionStore = await openCursorSessionStore(params.cwd, identities.sessionStore);
+		await runWithCursorSdkPlatformPackageVisible(async () => {
+			if (resumeHandle && resumeAttemptAllowed && resumeAgent) {
+				try {
+					agent = await resumeAgent(resumeHandle.agentId, buildAgentOptions());
+					effectiveSendState = { ...resumeHandle.sendState };
+					resumed = true;
+				} catch {
+					if (persistentStore) resumeNotice = LOCAL_RESUME_FALLBACK_NOTICE;
+					const currentStore = sessionStore;
+					if (currentStore && !cursorSessionStoreIdentitiesEqual(currentStore.identity, identities.sessionStore)) {
+						await currentStore.dispose().catch(() => undefined);
+						sessionStore = await openCursorSessionStore(params.cwd, identities.sessionStore);
+					}
 				}
 			}
-		}
-		agent ??= await createAgent(buildAgentOptions());
+			agent ??= await createAgent(buildAgentOptions());
+		});
 		if (!agent) throw new Error("Cursor SDK agent creation returned no agent");
 		if (!sessionStore) throw new Error("Cursor SDK session store was not opened");