pi-cursor-sdk 0.1.60 → 0.1.61

package/scripts/lib/cloud-smoke-shutdown.mjs

@@ -0,0 +1,133 @@
+export function createCloudSmokeShutdownController(terminate) {
+	if (typeof terminate !== "function") throw new TypeError("terminate must be a function");
+	const activeChildren = new Set();
+	const abortController = new AbortController();
+	let shutdownPromise;
+	let reason;
+	let requestedSignal;
+	let terminationFailureReason;
+
+	const terminationFailure = (error) => {
+		if (terminationFailureReason) return terminationFailureReason;
+		terminationFailureReason = new Error(`cloud smoke ${requestedSignal} child termination failed`, { cause: error });
+		terminationFailureReason.signal = requestedSignal;
+		reason = terminationFailureReason;
+		return terminationFailureReason;
+	};
+
+	const track = async (child) => {
+		if (abortController.signal.aborted) {
+			try {
+				await terminate(child);
+			} catch (error) {
+				throw terminationFailure(error);
+			}
+			throw reason;
+		}
+		activeChildren.add(child);
+		const untrack = () => activeChildren.delete(child);
+		child.once?.("close", untrack);
+		return untrack;
+	};
+
+	const request = async (signalName) => {
+		if (!abortController.signal.aborted) {
+			requestedSignal = signalName;
+			const interruptReason = new Error(`cloud smoke interrupted by ${signalName}`);
+			interruptReason.signal = signalName;
+			reason = interruptReason;
+			const terminations = [...activeChildren].map((child) => Promise.resolve().then(() => terminate(child)));
+			shutdownPromise = Promise.allSettled(terminations).then((results) => {
+				const failed = results.find((result) => result.status === "rejected");
+				if (failed) throw terminationFailure(failed.reason);
+			});
+			abortController.abort(interruptReason);
+		}
+		await shutdownPromise;
+		return reason;
+	};
+
+	return {
+		signal: abortController.signal,
+		track,
+		request,
+		get reason() { return reason; },
+		wait: () => shutdownPromise ?? Promise.resolve(),
+		throwIfRequested() {
+			if (abortController.signal.aborted) throw reason;
+		},
+	};
+}
+
+export async function awaitCloudSmokeShutdown(shutdown, tracking = Promise.resolve()) {
+	const results = await Promise.allSettled([shutdown.wait(), tracking]);
+	const failed = results.find((result) => result.status === "rejected");
+	const outcome = failed?.reason ?? shutdown.reason;
+	return outcome instanceof Error ? outcome : new Error("cloud smoke shutdown failed", { cause: outcome });
+}
+
+export async function checkpointCloudSmokeShutdown(shutdown) {
+	await new Promise((resolve) => setImmediate(resolve));
+	shutdown.throwIfRequested();
+}
+
+export function createCloudSmokeTerminalFailureState(rejectPending) {
+	let failure;
+	return {
+		record(error) {
+			failure ??= error;
+			rejectPending(failure);
+		},
+		throwIfFailed() {
+			if (failure) throw failure;
+		},
+	};
+}
+
+export async function stopCloudSmokeTrackedChild(shutdown, tracking, terminateChild) {
+	const termination = Promise.resolve().then(terminateChild);
+	const [terminationResult] = await Promise.allSettled([termination]);
+	if (shutdown.signal.aborted) {
+		const results = await Promise.allSettled([shutdown.wait(), tracking, termination]);
+		const failed = results.find((result) => result.status === "rejected");
+		if (failed) throw failed.reason instanceof Error ? failed.reason : new Error("cloud smoke child termination failed", { cause: failed.reason });
+		return shutdown.reason;
+	}
+	if (terminationResult.status === "rejected") throw terminationResult.reason;
+	return undefined;
+}
+
+export function routeCloudSmokeChildError(shutdown, onShutdown, onError, error) {
+	if (shutdown.signal.aborted) onShutdown();
+	else onError(error);
+}
+
+export function installCloudSmokeChildErrorHandlers(child, shutdown, onShutdown, onError) {
+	const routeError = (error) => routeCloudSmokeChildError(shutdown, onShutdown, onError, error);
+	child.once("error", routeError);
+	child.stdin?.on?.("error", routeError);
+	return routeError;
+}
+
+export function routeCloudSmokeChildClose(shutdown, timedOut, onShutdown, onClose, result) {
+	if (shutdown.signal.aborted) onShutdown();
+	else if (!timedOut) onClose(result);
+}
+
+export function installCloudSmokeSignalHandlers(shutdown, processLike = process, onSignal) {
+	const handlers = new Map();
+	for (const signalName of ["SIGINT", "SIGTERM"]) {
+		const handler = () => {
+			try {
+				onSignal?.(signalName);
+			} finally {
+				void shutdown.request(signalName).catch(() => {});
+			}
+		};
+		handlers.set(signalName, handler);
+		processLike.on(signalName, handler);
+	}
+	return () => {
+		for (const [signalName, handler] of handlers) processLike.off(signalName, handler);
+	};
+}

package/scripts/lib/local-resume-smoke-harness.mjs

@@ -28,6 +28,8 @@ const CLOUD_RUNTIME_ENV_NAMES = [
 	"PI_CURSOR_CLOUD_REPO",
 	"PI_CURSOR_CLOUD_BRANCH",
 	"PI_CURSOR_CLOUD_DIRECT_PUSH",
+	"PI_CURSOR_CLOUD_AUTO_CREATE_PR",
+	"PI_CURSOR_CLOUD_SKIP_REVIEWER_REQUEST",
 	"PI_CURSOR_CLOUD_ENV",
 	"PI_CURSOR_CLOUD_ENV_FROM_FILES",
 	"PI_CURSOR_CLOUD_ENV_TYPE",

package/scripts/local-resume-cleanup-smoke.mjs

@@ -25,6 +25,7 @@ export async function runCleanupSmoke() {
 	let oldAgentId;
 	let newAgentId;
 	let oldResumeEntryId;
+	let oldStoreIdentity;
 	console.error(scrubSmokeText(`[local-resume-smoke] artifacts: ${artifactRoot}`));
 	try {
 		await withRpc({ artifactDir: artifactRoot, sessionDir, sessionId }, async (rpc) => {
@@ -37,8 +38,13 @@ export async function runCleanupSmoke() {
 			});
 			assertTurnMetadata("cleanup baseline", baseline, { resumedAgent: false });
 			oldAgentId = baseline.metadata.run.agentId;
-			oldResumeEntryId = resumeEntries(await getEntries(rpc)).at(-1)?.id;
+			const baselineHandle = resumeEntries(await getEntries(rpc)).at(-1);
+			oldResumeEntryId = baselineHandle?.id;
+			oldStoreIdentity = baselineHandle?.data?.storeIdentity;
 			if (!oldResumeEntryId) fail("cleanup baseline did not persist a resume entry");
+			if (baselineHandle?.data?.version !== 2 || !oldStoreIdentity?.stateRoot?.includes("pi-sessions")) {
+				fail("cleanup baseline did not persist a per-session store identity", JSON.stringify(baselineHandle?.data, null, 2));
+			}
 		});
 
 		await withRpc({ artifactDir: artifactRoot, sessionDir, sessionId, bridge: true, exposeBuiltinTools: true }, async (rpc) => {
@@ -52,7 +58,10 @@ export async function runCleanupSmoke() {
 			assertNotResumedFrom("cleanup changed tool surface", changedSurface, oldAgentId);
 			newAgentId = changedSurface.metadata.run.agentId;
 			const changedHandle = latestResumeEntry(await getEntries(rpc));
-			if (!changedHandle?.cleanupCandidateAgentIds?.includes(oldAgentId)) fail("changed tool surface did not record old agent cleanup candidate", JSON.stringify({ oldAgentId, changedHandle }, null, 2));
+			const cleanupCandidate = changedHandle?.cleanupCandidates?.find((candidate) => candidate.agentId === oldAgentId);
+			if (!cleanupCandidate || JSON.stringify(cleanupCandidate.storeIdentity) !== JSON.stringify(oldStoreIdentity)) {
+				fail("changed tool surface did not record old agent cleanup candidate with its store identity", JSON.stringify({ oldAgentId, oldStoreIdentity, changedHandle }, null, 2));
+			}
 
 			await rpcData(rpc, "prompt", { message: "/cursor-local-resume-cleanup --dry-run" }, timeoutMs);
 			let latestCleanup = (await waitForCleanupEntryCount(rpc, 1, timeoutMs)).at(-1)?.data;

package/scripts/platform-smoke/card-detect.mjs

@@ -30,6 +30,7 @@ const CARD_PATTERNS = [
 	},
 	{ id: "bridge-read-failure", pattern: /^\s*(?:read \.\/definitely-missing-platform-smoke-file\.txt|ENOENT: no such file)\s*/i },
 	{ id: "bridge-shell-success", pattern: /^\s*bridge visual smoke\s*$/i },
+	{ id: "http1-status", pattern: /\bcursor:local\b.*\bhttp1\b/i },
 	{ id: "footer-status", pattern: /\bcomposer-2-5\b|\bcomposer-2\.5\b/i },
 ];
 

package/scripts/platform-smoke/scenarios.d.mts

@@ -0,0 +1,22 @@
+interface PlatformSmokeScenario {
+	description: string;
+	cursorCalls: number;
+	env?: Record<string, string>;
+	commands?: Record<string, { posix?: string; powershell?: string }>;
+	promptTemplate?: string;
+	finalMarker?: string | null;
+	requiredCards?: string[];
+	requiredJSONLTools?: Array<{ name: string }>;
+	requiredJSONLResults?: Array<Record<string, unknown>>;
+	expectedJSONLResultToolOrder?: string[];
+	visualEvidence?: Array<Record<string, unknown>>;
+	requiredBridgeDiagnostics?: boolean | "abort";
+}
+
+interface PlatformSmokePromptScenario extends PlatformSmokeScenario {
+	promptTemplate: string;
+}
+
+export const SCENARIOS: Record<string, PlatformSmokeScenario>;
+export function getScenario(name: string): PlatformSmokeScenario | null;
+export function renderPrompt(scenario: PlatformSmokePromptScenario, platform: string): string;

package/scripts/platform-smoke/scenarios.mjs

@@ -96,6 +96,23 @@ NATIVE_MATRIX_OK package=<name> grep=<yes/no> find=<yes/no> list=<yes/no> shell=
 		],
 	},
 
+	"cursor-http1-live": {
+		description: "Prove an opt-in HTTP/1.1/SSE local provider turn and visible transport status.",
+		cursorCalls: 1,
+		env: {
+			PI_CURSOR_SETTING_SOURCES: "none",
+			PI_CURSOR_HTTP_1_1: "1",
+			PI_CURSOR_NATIVE_TOOL_DISPLAY: "1",
+			PI_CURSOR_REGISTER_NATIVE_TOOLS: "1",
+			PI_CURSOR_PI_TOOL_BRIDGE: "0",
+			PI_CURSOR_EXPOSE_BUILTIN_TOOLS: "0",
+			PI_CURSOR_SDK_EVENT_DEBUG: "1",
+		},
+		promptTemplate: "Reply exactly HTTP1_LIVE_OK.",
+		finalMarker: "HTTP1_LIVE_OK",
+		requiredCards: ["http1-status"],
+	},
+
 	"cursor-bridge-visual-matrix": {
 		description: "Prove pi bridge routing, bridge tool cards, diagnostics, real pi tool names.",
 		cursorCalls: 1,

package/scripts/platform-smoke/targets.mjs

@@ -119,6 +119,7 @@ export async function runTargetSuite(config, targetName, suiteName, leaseSession
 		case "platform-build":
 			return await executePlatformBuild(config, targetName, suiteDir, slug, platform, leaseSession);
 		case "cursor-native-visual-matrix":
+		case "cursor-http1-live":
 		case "cursor-bridge-visual-matrix":
 		case "cursor-abort-cleanup":
 			return await executeLiveSuite(config, targetName, suiteName, suiteDir, slug, leaseSession);

package/src/cursor-agent-message-web-tools.ts

@@ -1,4 +1,4 @@
-import type { AgentMessage } from "@cursor/sdk";
+import type { AgentMessage, LocalAgentStore } from "@cursor/sdk";
 import { asRecord, getArray, getString } from "./cursor-record-utils.js";
 import { stringifyUnknown } from "./cursor-transcript-utils.js";
 import { loadCursorSdk } from "./cursor-sdk-runtime.js";
@@ -22,22 +22,28 @@ function getOneofCaseValue(value: unknown, caseName: string): unknown {
 	return record[caseName];
 }
 
-async function hasCursorAgentMessageAt(agentId: string, cwd: string, offset: number): Promise<boolean> {
+async function hasCursorAgentMessageAt(agentId: string, cwd: string, offset: number, store?: LocalAgentStore): Promise<boolean> {
 	const { Agent } = await loadCursorSdk();
-	const messages = await Agent.messages.list(agentId, { runtime: "local", cwd, limit: 1, offset });
+	const messages = await Agent.messages.list(agentId, {
+		runtime: "local",
+		cwd,
+		...(store ? { store } : {}),
+		limit: 1,
+		offset,
+	});
 	return messages.length > 0;
 }
 
-export async function countCursorAgentMessages(agentId: string, cwd: string): Promise<number> {
+export async function countCursorAgentMessages(agentId: string, cwd: string, store?: LocalAgentStore): Promise<number> {
 	let high = 1;
-	while (await hasCursorAgentMessageAt(agentId, cwd, high)) {
+	while (await hasCursorAgentMessageAt(agentId, cwd, high, store)) {
 		high *= 2;
 	}
 
 	let low = 0;
 	while (low < high) {
 		const mid = Math.floor((low + high) / 2);
-		if (await hasCursorAgentMessageAt(agentId, cwd, mid)) low = mid + 1;
+		if (await hasCursorAgentMessageAt(agentId, cwd, mid, store)) low = mid + 1;
 		else high = mid;
 	}
 	return low;
@@ -47,12 +53,14 @@ export async function loadCursorTranscriptWebToolCallsAfterOffset(options: {
 	agentId: string;
 	cwd: string;
 	offset: number | undefined;
+	store?: LocalAgentStore;
 }): Promise<CursorTranscriptCompletedToolCall[]> {
 	if (options.offset === undefined) return [];
 	const { Agent } = await loadCursorSdk();
 	const messages = await Agent.messages.list(options.agentId, {
 		runtime: "local",
 		cwd: options.cwd,
+		...(options.store ? { store: options.store } : {}),
 		limit: CURSOR_AGENT_MESSAGE_PAGE_LIMIT,
 		offset: options.offset,
 	});