@bastani/atomic 0.8.28-alpha.4 → 0.8.29-alpha.2

package/dist/builtin/cursor/src/catalog-cache.ts

@@ -0,0 +1,155 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import type { CursorModelCatalog, CursorUsableModel } from "./model-mapper.js";
+
+export const CURSOR_CATALOG_CACHE_VERSION = 1;
+export const CURSOR_CATALOG_CACHE_FILENAME = "cursor-model-catalog.json";
+
+export interface CursorCatalogCacheRecord {
+	readonly version: typeof CURSOR_CATALOG_CACHE_VERSION;
+	readonly fetchedAt: number;
+	readonly models: readonly CursorUsableModel[];
+}
+
+export interface CursorCatalogCache {
+	load(): CursorModelCatalog | null;
+	save(catalog: CursorModelCatalog): void;
+}
+
+export class FileCursorCatalogCache implements CursorCatalogCache {
+	readonly #path: string;
+
+	constructor(path = getDefaultCursorCatalogCachePath()) {
+		this.#path = path;
+	}
+
+	get path(): string {
+		return this.#path;
+	}
+
+	load(): CursorModelCatalog | null {
+		if (!existsSync(this.#path)) return null;
+		try {
+			return parseCursorCatalogCacheRecord(JSON.parse(readFileSync(this.#path, "utf8")));
+		} catch {
+			return null;
+		}
+	}
+
+	save(catalog: CursorModelCatalog): void {
+		const record = toCursorCatalogCacheRecord(catalog);
+		if (!record) return;
+		mkdirSync(dirname(this.#path), { recursive: true });
+		const tmpPath = `${this.#path}.${process.pid}.${randomUUID()}.tmp`;
+		try {
+			writeFileSync(tmpPath, `${JSON.stringify(record, null, 2)}\n`, { encoding: "utf8", mode: 0o600 });
+			renameSync(tmpPath, this.#path);
+		} catch (error) {
+			try {
+				rmSync(tmpPath, { force: true });
+			} catch {
+				// Ignore cleanup errors; preserve the original write/rename failure.
+			}
+			throw error;
+		}
+	}
+}
+
+export function getDefaultCursorCatalogCachePath(): string {
+	return join(getDefaultAtomicAgentDir(), CURSOR_CATALOG_CACHE_FILENAME);
+}
+
+export function parseCursorCatalogCacheRecord(value: unknown): CursorModelCatalog | null {
+	if (!isRecord(value)) return null;
+	if (value.version !== CURSOR_CATALOG_CACHE_VERSION) return null;
+	if (typeof value.fetchedAt !== "number" || !Number.isFinite(value.fetchedAt) || value.fetchedAt < 0) return null;
+	if (!Array.isArray(value.models)) return null;
+	const models = value.models.map(parseCachedCursorModel).filter((model): model is CursorUsableModel => model !== null);
+	if (models.length === 0) return null;
+	return { source: "live", fetchedAt: value.fetchedAt, models };
+}
+
+export function toCursorCatalogCacheRecord(catalog: CursorModelCatalog): CursorCatalogCacheRecord | null {
+	if (catalog.source !== "live") return null;
+	if (typeof catalog.fetchedAt !== "number" || !Number.isFinite(catalog.fetchedAt) || catalog.fetchedAt < 0) return null;
+	const models = catalog.models.map(parseCachedCursorModel).filter((model): model is CursorUsableModel => model !== null);
+	if (models.length === 0) return null;
+	return { version: CURSOR_CATALOG_CACHE_VERSION, fetchedAt: catalog.fetchedAt, models };
+}
+
+function parseCachedCursorModel(value: unknown): CursorUsableModel | null {
+	if (!isRecord(value)) return null;
+	const id = readRequiredString(value, "id");
+	if (!id) return null;
+	const name = readOptionalString(value, "name");
+	const displayName = readOptionalString(value, "displayName");
+	const contextWindow = readOptionalPositiveNumber(value, "contextWindow");
+	const maxTokens = readOptionalPositiveNumber(value, "maxTokens");
+	const supportsReasoning = readOptionalBoolean(value, "supportsReasoning");
+	const supportsThinking = readOptionalBoolean(value, "supportsThinking");
+	if (
+		name === false ||
+		displayName === false ||
+		contextWindow === false ||
+		maxTokens === false ||
+		supportsReasoning === false ||
+		supportsThinking === false
+	) {
+		return null;
+	}
+	return {
+		id,
+		...(name !== undefined ? { name } : {}),
+		...(displayName !== undefined ? { displayName } : {}),
+		...(contextWindow !== undefined ? { contextWindow } : {}),
+		...(maxTokens !== undefined ? { maxTokens } : {}),
+		...(supportsReasoning !== undefined ? { supportsReasoning } : {}),
+		...(supportsThinking !== undefined ? { supportsThinking } : {}),
+	};
+}
+
+function getDefaultAtomicAgentDir(): string {
+	const configured = readEnv("ATOMIC_CODING_AGENT_DIR") ?? readEnv("PI_CODING_AGENT_DIR");
+	if (configured) return expandTilde(configured);
+	return join(homedir(), ".atomic", "agent");
+}
+
+function readEnv(name: string): string | undefined {
+	const value = process.env[name]?.trim();
+	return value ? value : undefined;
+}
+
+function expandTilde(path: string): string {
+	if (path === "~") return homedir();
+	if (path.startsWith("~/")) return resolve(homedir(), path.slice(2));
+	return resolve(path);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function readRequiredString(value: Record<string, unknown>, key: string): string | undefined {
+	const field = value[key];
+	return typeof field === "string" && field.length > 0 ? field : undefined;
+}
+
+function readOptionalString(value: Record<string, unknown>, key: string): string | undefined | false {
+	const field = value[key];
+	if (field === undefined) return undefined;
+	return typeof field === "string" ? field : false;
+}
+
+function readOptionalPositiveNumber(value: Record<string, unknown>, key: string): number | undefined | false {
+	const field = value[key];
+	if (field === undefined) return undefined;
+	return typeof field === "number" && Number.isFinite(field) && field > 0 ? field : false;
+}
+
+function readOptionalBoolean(value: Record<string, unknown>, key: string): boolean | undefined | false {
+	const field = value[key];
+	if (field === undefined) return undefined;
+	return typeof field === "boolean" ? field : false;
+}

package/dist/builtin/cursor/src/config.ts

@@ -0,0 +1,123 @@
+export const CURSOR_PROVIDER_ID = "cursor";
+export const CURSOR_PROVIDER_NAME = "Cursor";
+export const CURSOR_LOGIN_NAME = "Cursor";
+export const CURSOR_API = "cursor-agent";
+export const CURSOR_API_BASE_URL = "https://api2.cursor.sh";
+export const CURSOR_WEB_BASE_URL = "https://cursor.com";
+// Keep this in sync with Cursor CLI traffic if api2.cursor.sh starts rejecting
+// requests after a Cursor client release. Capture the current CLI headers from
+// a fresh Cursor login/model request and update this single constant.
+export const CURSOR_CLIENT_VERSION = "cli-2026.01.09-231024f";
+export const CURSOR_CLIENT_TYPE = "cli";
+export const CURSOR_DEFAULT_MODEL_ID = "composer-2";
+export const CURSOR_AUTH_POLL_PATH = "/auth/poll";
+export const CURSOR_REFRESH_PATH = "/auth/exchange_user_api_key";
+export const CURSOR_GET_USABLE_MODELS_PATH = "/agent.v1.AgentService/GetUsableModels";
+export const CURSOR_RUN_PATH = "/agent.v1.AgentService/Run";
+export const CURSOR_LOGIN_PATH = "/loginDeepControl";
+export const CURSOR_OAUTH_EXPIRY_SKEW_MS = 5 * 60 * 1000;
+export const CURSOR_DEFAULT_TOKEN_TTL_MS = 60 * 60 * 1000;
+
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export interface JsonObject {
+	[key: string]: JsonValue;
+}
+export type JsonArray = JsonValue[];
+
+export interface CursorRpcHeaders extends Record<string, string> {
+	readonly authorization: string;
+	readonly "content-type": string;
+	readonly te: string;
+	readonly "x-cursor-client-version": string;
+	readonly "x-cursor-client-type": string;
+	readonly "x-ghost-mode": string;
+	readonly "x-request-id": string;
+}
+
+export class CursorExperimentalProtocolError extends Error {
+	readonly code = "CURSOR_EXPERIMENTAL_PROTOCOL_ERROR";
+
+	constructor(message = "Cursor private protocol transport failed.") {
+		super(message);
+		this.name = "CursorExperimentalProtocolError";
+	}
+}
+
+export function createCursorExperimentalProtocolError(detail?: string): CursorExperimentalProtocolError {
+	return new CursorExperimentalProtocolError(
+		detail
+			? `Cursor protocol error: ${sanitizeDiagnosticText(detail)}`
+			: "Cursor protocol error: HTTP/2/protobuf transport failed.",
+	);
+}
+
+export function buildCursorRpcHeaders(accessToken: string, requestId: string, contentType: string): CursorRpcHeaders {
+	return {
+		authorization: `Bearer ${accessToken}`,
+		"content-type": contentType,
+		te: "trailers",
+		"x-cursor-client-version": CURSOR_CLIENT_VERSION,
+		"x-cursor-client-type": CURSOR_CLIENT_TYPE,
+		"x-ghost-mode": "true",
+		"x-request-id": requestId,
+	};
+}
+
+export function redactHeaders(headers: Record<string, string>): Record<string, string> {
+	const redacted: Record<string, string> = {};
+	for (const [key, value] of Object.entries(headers)) {
+		redacted[key] = key.toLowerCase() === "authorization" ? "[redacted]" : redactSensitiveText(value);
+	}
+	return redacted;
+}
+
+export function redactSensitiveText(text: string, secrets: readonly string[] = []): string {
+	let redacted = text.replace(/authorization\s*[:=]\s*bearer\s+[^\s"']+/gi, "authorization: Bearer [redacted]");
+	redacted = redacted.replace(/bearer\s+(eyJ[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+\.[a-zA-Z0-9_-]+)/gi, "Bearer [redacted]");
+	for (const secret of secrets) {
+		if (secret.length === 0) continue;
+		redacted = redacted.split(secret).join("[redacted]");
+	}
+	return redacted;
+}
+
+export function sanitizeDiagnosticText(text: string, secrets: readonly string[] = []): string {
+	return redactSensitiveText(text, secrets).slice(0, 1200);
+}
+
+export function isJsonObject(value: JsonValue): value is JsonObject {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+export function readStringField(value: JsonObject, key: string): string | undefined {
+	const field = value[key];
+	return typeof field === "string" ? field : undefined;
+}
+
+export function readNumberField(value: JsonObject, key: string): number | undefined {
+	const field = value[key];
+	return typeof field === "number" && Number.isFinite(field) ? field : undefined;
+}
+
+export function readBooleanField(value: JsonObject, key: string): boolean | undefined {
+	const field = value[key];
+	return typeof field === "boolean" ? field : undefined;
+}
+
+export function parseJsonObject(text: string): JsonObject | undefined {
+	try {
+		const parsed = JSON.parse(text) as JsonValue;
+		return isJsonObject(parsed) ? parsed : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export function parseJsonValue(text: string): JsonValue | undefined {
+	try {
+		return JSON.parse(text) as JsonValue;
+	} catch {
+		return undefined;
+	}
+}

package/dist/builtin/cursor/src/conversation-state.ts

@@ -0,0 +1,135 @@
+import type { CursorRunStream, CursorToolCallMessage, CursorToolResultMessage, CursorTransportLifecycleSnapshot, CursorWriteOptions } from "./transport.js";
+
+export interface CursorConversationSnapshot extends CursorTransportLifecycleSnapshot {
+	readonly activeTurns: number;
+}
+
+export interface PendingCursorToolCall {
+	readonly toolCallId: string;
+	readonly toolName: string;
+	readonly execId?: string;
+	readonly execNumericId?: number;
+}
+
+interface ActiveTurn {
+	readonly conversationId: string;
+	readonly stream: CursorRunStream;
+	readonly pendingTools: ReadonlyMap<string, PendingCursorToolCall>;
+	readonly abortCleanup?: () => void;
+	readonly idleTimer?: ReturnType<typeof setTimeout>;
+}
+
+export interface CursorPauseTurnOptions {
+	readonly signal?: AbortSignal;
+	readonly idleTimeoutMs?: number;
+}
+
+export type CursorResumeTurnOptions = CursorWriteOptions;
+
+export class CursorConversationStateStore {
+	readonly #activeTurns = new Map<string, ActiveTurn>();
+
+	registerTurn(conversationId: string, stream: CursorRunStream): void {
+		const existing = this.#activeTurns.get(conversationId);
+		if (existing) this.replaceExistingTurn(existing, stream);
+		this.#activeTurns.set(conversationId, { conversationId, stream, pendingTools: new Map() });
+	}
+
+	pauseTurnForTools(conversationId: string, stream: CursorRunStream, toolCalls: readonly CursorToolCallMessage[], options: CursorPauseTurnOptions = {}): void {
+		const existing = this.#activeTurns.get(conversationId);
+		if (existing && existing.stream !== stream) this.replaceExistingTurn(existing, stream);
+		else if (existing) this.cleanupTurn(existing);
+		const pendingTools = new Map<string, PendingCursorToolCall>();
+		for (const toolCall of toolCalls) {
+			pendingTools.set(toolCall.id, {
+				toolCallId: toolCall.id,
+				toolName: toolCall.name,
+				...(toolCall.execId ? { execId: toolCall.execId } : {}),
+				...(toolCall.execNumericId !== undefined ? { execNumericId: toolCall.execNumericId } : {}),
+			});
+		}
+		let abortCleanup: (() => void) | undefined;
+		if (options.signal) {
+			const onAbort = (): void => this.cancelTurnBestEffort(conversationId);
+			options.signal.addEventListener("abort", onAbort, { once: true });
+			abortCleanup = () => options.signal?.removeEventListener("abort", onAbort);
+		}
+		const idleTimer = options.idleTimeoutMs && options.idleTimeoutMs > 0 ? setTimeout(() => this.cancelTurnBestEffort(conversationId), options.idleTimeoutMs) : undefined;
+		idleTimer?.unref?.();
+		this.#activeTurns.set(conversationId, { conversationId, stream, pendingTools, ...(abortCleanup ? { abortCleanup } : {}), ...(idleTimer ? { idleTimer } : {}) });
+		if (options.signal?.aborted) this.cancelTurnBestEffort(conversationId);
+	}
+
+	async resumeTurnWithToolResults(conversationId: string, results: readonly CursorToolResultMessage[], options: CursorResumeTurnOptions = {}): Promise<CursorRunStream> {
+		const turn = this.#activeTurns.get(conversationId);
+		if (!turn) throw new Error(`Cursor has no paused tool turn for conversation ${conversationId}.`);
+		try {
+			for (const result of results) {
+				if (!turn.pendingTools.has(result.toolCallId)) throw new Error(`Cursor tool result ${result.toolCallId} does not match a paused tool call.`);
+			}
+			for (const result of results) {
+				const pending = turn.pendingTools.get(result.toolCallId);
+				if (!pending) throw new Error(`Cursor tool result ${result.toolCallId} does not match a paused tool call.`);
+				await turn.stream.writeToolResult({ ...result, execId: pending.execId, execNumericId: pending.execNumericId }, options);
+			}
+			if (this.#activeTurns.get(conversationId) !== turn) throw new Error(`Cursor paused tool turn for conversation ${conversationId} was cancelled before resume completed.`);
+			this.cleanupTurn(turn);
+			this.#activeTurns.set(conversationId, { conversationId, stream: turn.stream, pendingTools: new Map() });
+			return turn.stream;
+		} catch (error) {
+			if (this.#activeTurns.get(conversationId) === turn) await this.cancelSpecificTurn(turn).catch(() => undefined);
+			else this.cleanupTurn(turn);
+			throw error;
+		}
+	}
+
+	completeTurn(conversationId: string): void {
+		const turn = this.#activeTurns.get(conversationId);
+		if (turn) this.cleanupTurn(turn);
+		this.#activeTurns.delete(conversationId);
+	}
+
+	async cancelTurn(conversationId: string): Promise<void> {
+		const turn = this.#activeTurns.get(conversationId);
+		if (!turn) return;
+		await this.cancelSpecificTurn(turn);
+	}
+
+	async dispose(): Promise<void> {
+		const turns = [...this.#activeTurns.values()];
+		this.#activeTurns.clear();
+		await Promise.allSettled(turns.map(async (turn) => {
+			this.cleanupTurn(turn);
+			await turn.stream.cancel();
+		}));
+	}
+
+	private replaceExistingTurn(existing: ActiveTurn, replacementStream: CursorRunStream): void {
+		this.cleanupTurn(existing);
+		this.#activeTurns.delete(existing.conversationId);
+		if (existing.stream !== replacementStream) existing.stream.cancel().catch(() => undefined);
+	}
+
+	private cancelTurnBestEffort(conversationId: string): void {
+		this.cancelTurn(conversationId).catch(() => undefined);
+	}
+
+	private async cancelSpecificTurn(turn: ActiveTurn): Promise<void> {
+		this.cleanupTurn(turn);
+		if (this.#activeTurns.get(turn.conversationId) === turn) this.#activeTurns.delete(turn.conversationId);
+		await turn.stream.cancel();
+	}
+
+	private cleanupTurn(turn: ActiveTurn): void {
+		turn.abortCleanup?.();
+		if (turn.idleTimer) clearTimeout(turn.idleTimer);
+	}
+
+	get activeTurns(): number {
+		return this.#activeTurns.size;
+	}
+
+	snapshot(transport: CursorTransportLifecycleSnapshot): CursorConversationSnapshot {
+		return { ...transport, activeTurns: this.#activeTurns.size };
+	}
+}