@bastani/atomic 0.9.11-alpha.4 → 0.9.11-alpha.6

package/dist/builtin/cursor/src/proto/protobuf-codec.ts

@@ -1,200 +0,0 @@
-import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
-import { createCursorExperimentalProtocolError } from "../config.js";
-import type { CursorUsableModel } from "../model-mapper.js";
-import type { CursorConnectFrame, CursorProtocolCodec, CursorProtocolMessage, CursorRunRequest, CursorToolResultMessage } from "../transport.js";
-import {
-	AgentClientMessageSchema,
-	AgentServerMessageSchema,
-	CancelActionSchema,
-	ClientHeartbeatSchema,
-	ConversationActionSchema,
-	GetBlobResultSchema,
-	GetUsableModelsRequestSchema,
-	GetUsableModelsResponseSchema,
-	SetBlobResultSchema,
-	type McpToolDefinition,
-	type ModelDetails,
-} from "./agent_pb.js";
-import { blobKey, buildCursorRequest, buildMcpToolDefinitions, extractCurrentActionImages, extractCurrentActionText, parseHistoricalTurns } from "./protobuf-codec-request.js";
-import { createMcpToolResult, decodeAgentServerMessage, encodeExecClientMessage, encodeKvClientMessage, encodeNativeExecRejection, encodeRequestContextResult } from "./protobuf-codec-wire.js";
-
-// Cursor protocol codec intentionally follows the MIT-licensed
-// ndraiman/pi-cursor-provider implementation. The request/control bytes are
-// built through Cursor's generated protobuf descriptors instead of inferred
-// hand-written field concatenation so the private API sees the same semantic
-// messages as the reference provider.
-
-interface StoredCursorConversationState {
-	checkpoint?: Uint8Array;
-	blobStore: Map<string, Uint8Array>;
-}
-
-
-export class CursorProtobufProtocolCodec implements CursorProtocolCodec {
-	readonly #blobStores = new Map<string, Map<string, Uint8Array>>();
-	readonly #toolDefinitions = new Map<string, readonly McpToolDefinition[]>();
-	readonly #runConversationIds = new Map<string, string>();
-	readonly #conversationStates = new Map<string, StoredCursorConversationState>();
-
-	encodeGetUsableModelsRequest(): Uint8Array {
-		return toBinary(GetUsableModelsRequestSchema, create(GetUsableModelsRequestSchema, {}));
-	}
-
-	decodeGetUsableModelsResponse(data: Uint8Array): readonly CursorUsableModel[] {
-		try {
-			try {
-				const direct = decodeGetUsableModelsBody(data);
-				if (direct.length > 0) return direct;
-			} catch {
-				// Some Cursor deployments reply to unary calls with a Connect envelope;
-				// fall through and try the reference provider's unwrap behavior.
-			}
-			const unwrapped = unwrapConnectUnaryBody(data);
-			return unwrapped ? decodeGetUsableModelsBody(unwrapped) : [];
-		} catch (error) {
-			throw createCursorExperimentalProtocolError(`Cursor protobuf GetUsableModels decoding failed: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-
-	encodeRunRequest(request: CursorRunRequest): Uint8Array {
-		const conversationIdValue = request.conversationId ?? request.requestId;
-		const storedState = this.#conversationStates.get(conversationIdValue);
-		const payload = buildCursorRequest(
-			request.resolvedModelId,
-			request.context.systemPrompt ?? "",
-			extractCurrentActionText(request),
-			parseHistoricalTurns(request.context.messages.slice(0, -1)),
-			conversationIdValue,
-			storedState?.checkpoint ?? null,
-			storedState?.blobStore,
-			extractCurrentActionImages(request),
-		);
-		this.#blobStores.set(request.requestId, payload.blobStore);
-		this.#toolDefinitions.set(request.requestId, buildMcpToolDefinitions(request));
-		this.#runConversationIds.set(request.requestId, conversationIdValue);
-		return payload.requestBytes;
-	}
-
-	decodeRunFrame(frame: CursorConnectFrame): readonly CursorProtocolMessage[] {
-		try {
-			const message = fromBinary(AgentServerMessageSchema, frame.data);
-			return decodeAgentServerMessage(message);
-		} catch (error) {
-			throw createCursorExperimentalProtocolError(`Cursor protobuf Run decoding failed: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-
-	encodeServerResponse(message: CursorProtocolMessage, requestId: string): Uint8Array | undefined {
-		if (message.type === "kvGetBlob") {
-			const data = this.#blobStores.get(requestId)?.get(blobKey(message.blobId));
-			return encodeKvClientMessage(message.id, "getBlobResult", create(GetBlobResultSchema, data ? { blobData: data } : {}));
-		}
-		if (message.type === "kvSetBlob") {
-			const store = this.#blobStores.get(requestId);
-			if (store) store.set(blobKey(message.blobId), message.blobData);
-			this.commitRunState(requestId);
-			return encodeKvClientMessage(message.id, "setBlobResult", create(SetBlobResultSchema, {}));
-		}
-		if (message.type === "conversationCheckpoint") {
-			this.commitRunState(requestId, message.checkpoint);
-			return undefined;
-		}
-		if (message.type === "requestContext") {
-			return encodeRequestContextResult(message, this.#toolDefinitions.get(requestId) ?? []);
-		}
-		if (message.type === "nonMcpExec") {
-			return encodeNativeExecRejection(message);
-		}
-		return undefined;
-	}
-
-	disposeRun(requestId: string): void {
-		this.commitRunState(requestId);
-		this.cleanupRun(requestId);
-	}
-
-	discardRun(requestId: string): void {
-		const conversationId = this.#runConversationIds.get(requestId);
-		if (conversationId) this.discardConversation(conversationId);
-		this.cleanupRun(requestId);
-	}
-
-	discardConversation(conversationId: string): void {
-		this.#conversationStates.delete(conversationId);
-	}
-
-	private cleanupRun(requestId: string): void {
-		this.#blobStores.delete(requestId);
-		this.#toolDefinitions.delete(requestId);
-		this.#runConversationIds.delete(requestId);
-	}
-
-	private commitRunState(requestId: string, checkpoint?: Uint8Array): void {
-		const conversationId = this.#runConversationIds.get(requestId);
-		if (!conversationId) return;
-		const runBlobStore = this.#blobStores.get(requestId);
-		const stored = this.#conversationStates.get(conversationId) ?? { blobStore: new Map<string, Uint8Array>() };
-		if (runBlobStore) {
-			for (const [key, value] of runBlobStore) stored.blobStore.set(key, value);
-		}
-		if (checkpoint && checkpoint.byteLength > 0) stored.checkpoint = checkpoint.slice();
-		this.#conversationStates.set(conversationId, stored);
-	}
-
-	encodeToolResult(result: CursorToolResultMessage): Uint8Array {
-		const mcpResult = createMcpToolResult(result.content ?? result.text, result.isError, result.text);
-		return encodeExecClientMessage(result.execNumericId, result.execId, "mcpResult", mcpResult);
-	}
-
-	encodeCancelRequest(): Uint8Array {
-		const cancelAction = create(ConversationActionSchema, {
-			action: { case: "cancelAction", value: create(CancelActionSchema, {}) },
-		});
-		const clientMessage = create(AgentClientMessageSchema, {
-			message: { case: "conversationAction", value: cancelAction },
-		});
-		return toBinary(AgentClientMessageSchema, clientMessage);
-	}
-
-	encodeHeartbeatRequest(): Uint8Array {
-		const clientMessage = create(AgentClientMessageSchema, {
-			message: { case: "clientHeartbeat", value: create(ClientHeartbeatSchema, {}) },
-		});
-		return toBinary(AgentClientMessageSchema, clientMessage);
-	}
-}
-
-function decodeGetUsableModelsBody(data: Uint8Array): readonly CursorUsableModel[] {
-	const decoded = fromBinary(GetUsableModelsResponseSchema, data);
-	return decoded.models.flatMap((model) => {
-		const normalized = modelDetailsToCursorUsableModel(model);
-		return normalized ? [normalized] : [];
-	});
-}
-
-function modelDetailsToCursorUsableModel(model: ModelDetails): CursorUsableModel | undefined {
-	const id = model.modelId.trim();
-	if (!id) return undefined;
-	return {
-		id,
-		displayName: model.displayName || model.displayNameShort || model.displayModelId || undefined,
-		supportsThinking: Boolean(model.thinkingDetails),
-		supportsReasoning: Boolean(model.thinkingDetails || model.maxMode),
-	};
-}
-
-function unwrapConnectUnaryBody(data: Uint8Array): Uint8Array | undefined {
-	let offset = 0;
-	while (offset + 5 <= data.byteLength) {
-		const flags = data[offset] ?? 0;
-		const view = new DataView(data.buffer, data.byteOffset + offset, data.byteLength - offset);
-		const length = view.getUint32(1, false);
-		const frameEnd = offset + 5 + length;
-		if (frameEnd > data.byteLength) return undefined;
-		if ((flags & 0b0000_0001) !== 0) return undefined;
-		if ((flags & 0b0000_0010) === 0) return data.slice(offset + 5, frameEnd);
-		offset = frameEnd;
-	}
-	return undefined;
-}
-

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

@@ -1,301 +0,0 @@
-import { randomUUID as nodeRandomUUID } from "node:crypto";
-import type {
-	Api,
-	AssistantMessageEventStream,
-	Context,
-	Model,
-	OAuthCredentials,
-	OAuthLoginCallbacks,
-	SimpleStreamOptions,
-} from "@earendil-works/pi-ai/compat";
-import {
-	CURSOR_API,
-	CURSOR_API_BASE_URL,
-	CURSOR_LOGIN_NAME,
-	CURSOR_PROVIDER_ID,
-	CURSOR_PROVIDER_NAME,
-} from "./config.js";
-import { CursorAuthService } from "./auth.js";
-import { FileCursorCatalogCache, type CursorCatalogCache } from "./catalog-cache.js";
-import { CursorConversationStateStore } from "./conversation-state.js";
-import { CursorModelDiscoveryService } from "./models.js";
-import {
-	createEstimatedCursorCatalog,
-	mapCursorCatalogToProviderModels,
-	type CursorModelCatalog,
-	type CursorProviderModelDefinition,
-} from "./model-mapper.js";
-import { CursorStreamAdapter } from "./stream.js";
-import { Http2CursorAgentTransport, type CursorAgentTransport } from "./transport.js";
-
-const DEFAULT_CATALOG_DISCOVERY_DISPOSE_TIMEOUT_MS = 1_000;
-
-export interface CursorProviderOAuthConfig {
-	readonly name: string;
-	login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials>;
-	refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials>;
-	getApiKey(credentials: OAuthCredentials): string;
-}
-
-export interface CursorProviderConfig {
-	readonly name: string;
-	readonly baseUrl: string;
-	readonly api: string;
-	readonly models: readonly CursorProviderModelDefinition[];
-	readonly oauth: CursorProviderOAuthConfig;
-	readonly streamSimple: (model: Model<Api>, context: Context, options?: SimpleStreamOptions) => AssistantMessageEventStream;
-}
-
-export type CursorSessionLifecycleEvent = "session_before_switch" | "session_before_fork" | "session_before_tree" | "session_shutdown";
-export type CursorProviderEvent = "session_start" | CursorSessionLifecycleEvent;
-
-export interface CursorProviderContext {
-	readonly sessionManager?: {
-		getSessionId?(): string;
-	};
-	readonly modelRegistry?: {
-		getApiKeyForProvider?(provider: string): Promise<string | undefined> | string | undefined;
-	};
-}
-
-export interface CursorProviderHost {
-	registerProvider(name: string, config: CursorProviderConfig): void;
-	on(event: CursorProviderEvent, handler: (event?: unknown, context?: CursorProviderContext) => Promise<void> | void): void;
-}
-
-export interface CursorProviderRegistrationOptions {
-	readonly transport?: CursorAgentTransport;
-	readonly authService?: CursorAuthService;
-	readonly discoveryService?: CursorModelDiscoveryService;
-	readonly streamAdapter?: CursorStreamAdapter;
-	readonly catalogCache?: CursorCatalogCache;
-	readonly catalogDiscoveryDisposeTimeoutMs?: number;
-	readonly uuid?: () => string;
-}
-
-export interface CursorProviderRuntime {
-	readonly transport: CursorAgentTransport;
-	readonly authService: CursorAuthService;
-	readonly discoveryService: CursorModelDiscoveryService;
-	readonly streamAdapter: CursorStreamAdapter;
-	readonly catalogCache: CursorCatalogCache;
-	dispose(): Promise<void>;
-}
-
-function defaultCursorUuid(): string {
-	return nodeRandomUUID();
-}
-
-export function registerCursorProvider(pi: CursorProviderHost, options: CursorProviderRegistrationOptions = {}): CursorProviderRuntime {
-	const transport = options.transport ?? new Http2CursorAgentTransport();
-	const uuid = options.uuid ?? defaultCursorUuid;
-	const authService = options.authService ?? new CursorAuthService({ uuid });
-	const discoveryService = options.discoveryService ?? new CursorModelDiscoveryService({ transport });
-	const catalogCache = options.catalogCache ?? new FileCursorCatalogCache();
-	const catalogDiscoveryDisposeTimeoutMs = options.catalogDiscoveryDisposeTimeoutMs ?? DEFAULT_CATALOG_DISCOVERY_DISPOSE_TIMEOUT_MS;
-	const streamAdapter = options.streamAdapter ?? new CursorStreamAdapter({
-		transport,
-		conversationState: new CursorConversationStateStore(),
-		uuid,
-	});
-	const catalogDiscoveryTasks = new Set<Promise<boolean>>();
-	const catalogDiscoveryAbortControllers = new Set<AbortController>();
-	const catalogDiscoveryTokens = new Set<string>();
-	const catalogDiscoveryInFlightTokens = new Map<string, Promise<boolean>>();
-	let firstUseRediscoveryTask: Promise<boolean> | undefined;
-	let disposed = false;
-	let disposePromise: Promise<void> | undefined;
-
-	const loadCachedLiveCatalog = (): CursorModelCatalog | null => {
-		try {
-			return catalogCache.load();
-		} catch {
-			return null;
-		}
-	};
-
-	const saveLiveCatalog = (catalog: CursorModelCatalog): boolean => {
-		try {
-			catalogCache.save(catalog);
-			return true;
-		} catch {
-			// Cache writes are best-effort and must never make auth/model use fail.
-			return false;
-		}
-	};
-
-	const registerCatalog = (catalogModels: readonly CursorProviderModelDefinition[]): void => {
-		pi.registerProvider(CURSOR_PROVIDER_ID, {
-			name: CURSOR_PROVIDER_NAME,
-			baseUrl: CURSOR_API_BASE_URL,
-			api: CURSOR_API,
-			models: catalogModels,
-			oauth: {
-				name: CURSOR_LOGIN_NAME,
-				async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
-					const credentials = await authService.login(callbacks);
-					await registerLiveCatalogBestEffort(credentials.access, uuid(), callbacks.signal);
-					return credentials;
-				},
-				async refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
-					const refreshed = await authService.refreshToken(credentials);
-					scheduleTrackedCatalogDiscovery(refreshed.access);
-					return refreshed;
-				},
-				getApiKey(credentials: OAuthCredentials): string {
-					return credentials.access;
-				},
-			},
-			streamSimple(model: Model<Api>, context: Context, streamOptions?: SimpleStreamOptions): AssistantMessageEventStream {
-				scheduleFirstUseRediscovery(streamOptions?.apiKey);
-				return streamAdapter.streamSimple(model, context, streamOptions);
-			},
-		});
-	};
-
-	const registerLiveCatalog = (catalog: CursorModelCatalog): boolean => {
-		if (disposed) return false;
-		if (!saveLiveCatalog(catalog)) return false;
-		registerCatalog(mapCursorCatalogToProviderModels(catalog));
-		return true;
-	};
-
-	const discoverAndRegisterLiveCatalog = async (accessToken: string, requestId: string, signal: AbortSignal | undefined): Promise<boolean> => {
-		const liveCatalog = await discoveryService.discover(accessToken, requestId, signal);
-		return registerLiveCatalog(liveCatalog);
-	};
-
-	const registerLiveCatalogBestEffort = async (accessToken: string, requestId: string, signal: AbortSignal | undefined): Promise<boolean> => {
-		try {
-			const registered = await discoverAndRegisterLiveCatalog(accessToken, requestId, signal);
-			if (!registered) return false;
-			catalogDiscoveryTokens.add(accessToken);
-			return true;
-		} catch {
-			// Login, refresh, startup, and first-use discovery are best-effort in the reference provider.
-			// Never leak tokens via discovery errors/logs and keep the current fallback/cached catalog.
-			return false;
-		}
-	};
-
-	const scheduleTrackedCatalogDiscovery = (accessToken: string): Promise<boolean> | undefined => {
-		if (disposed || accessToken.trim().length === 0 || catalogDiscoveryTokens.has(accessToken)) return undefined;
-		const existing = catalogDiscoveryInFlightTokens.get(accessToken);
-		if (existing) return existing;
-		let requestId: string;
-		try {
-			requestId = uuid();
-		} catch {
-			return undefined;
-		}
-		const controller = new AbortController();
-		catalogDiscoveryAbortControllers.add(controller);
-		const task = registerLiveCatalogBestEffort(accessToken, requestId, controller.signal);
-		catalogDiscoveryInFlightTokens.set(accessToken, task);
-		catalogDiscoveryTasks.add(task);
-		task.then(
-			() => {
-				catalogDiscoveryInFlightTokens.delete(accessToken);
-				catalogDiscoveryTasks.delete(task);
-				catalogDiscoveryAbortControllers.delete(controller);
-			},
-			() => {
-				catalogDiscoveryInFlightTokens.delete(accessToken);
-				catalogDiscoveryTasks.delete(task);
-				catalogDiscoveryAbortControllers.delete(controller);
-			},
-		);
-		return task;
-	};
-
-	const scheduleFirstUseRediscovery = (accessToken: string | undefined): void => {
-		if (!accessToken || firstUseRediscoveryTask || disposed) return;
-		const task = scheduleTrackedCatalogDiscovery(accessToken);
-		if (!task) return;
-		firstUseRediscoveryTask = task;
-		task.then(
-			(success) => {
-				if (!success && firstUseRediscoveryTask === task) firstUseRediscoveryTask = undefined;
-			},
-			() => {
-				if (firstUseRediscoveryTask === task) firstUseRediscoveryTask = undefined;
-			},
-		);
-	};
-
-	const discoverCatalogFromStoredCredentials = async (_event?: unknown, context?: CursorProviderContext): Promise<void> => {
-		if (disposed) return;
-		let accessToken: string | undefined;
-		try {
-			accessToken = await context?.modelRegistry?.getApiKeyForProvider?.(CURSOR_PROVIDER_ID);
-		} catch {
-			return;
-		}
-		if (!accessToken) return;
-		scheduleTrackedCatalogDiscovery(accessToken);
-	};
-
-	const cleanupCurrentSession = async (_event?: unknown, context?: CursorProviderContext): Promise<void> => {
-		const sessionId = context?.sessionManager?.getSessionId?.();
-		if (sessionId) await streamAdapter.cleanupSession(sessionId);
-	};
-
-	const disposeRuntime = async (): Promise<void> => {
-		if (disposePromise) return disposePromise;
-		disposePromise = (async () => {
-			await waitForCatalogDiscoveryTasks(catalogDiscoveryTasks, catalogDiscoveryDisposeTimeoutMs);
-			disposed = true;
-			for (const controller of catalogDiscoveryAbortControllers) {
-				controller.abort();
-			}
-			await streamAdapter.dispose();
-		})();
-		return disposePromise;
-	};
-
-	const startupCatalog = loadCachedLiveCatalog() ?? createEstimatedCursorCatalog();
-	registerCatalog(mapCursorCatalogToProviderModels(startupCatalog));
-
-	const cleanupCurrentSessionAndDispose = async (event?: unknown, context?: CursorProviderContext): Promise<void> => {
-		try {
-			await cleanupCurrentSession(event, context);
-		} finally {
-			await disposeRuntime();
-		}
-	};
-
-	pi.on("session_start", discoverCatalogFromStoredCredentials);
-	pi.on("session_before_switch", cleanupCurrentSession);
-	pi.on("session_before_fork", cleanupCurrentSession);
-	pi.on("session_before_tree", cleanupCurrentSession);
-	pi.on("session_shutdown", cleanupCurrentSessionAndDispose);
-
-	return {
-		transport,
-		authService,
-		discoveryService,
-		streamAdapter,
-		catalogCache,
-		dispose: disposeRuntime,
-	};
-}
-
-async function waitForCatalogDiscoveryTasks(tasks: ReadonlySet<Promise<boolean>>, timeoutMs: number): Promise<void> {
-	const pending = [...tasks];
-	if (pending.length === 0 || timeoutMs <= 0) return;
-	let timer: ReturnType<typeof setTimeout> | undefined;
-	try {
-		await Promise.race([
-			Promise.allSettled(pending).then(() => undefined),
-			new Promise<void>((resolve) => {
-				timer = setTimeout(resolve, timeoutMs);
-			}),
-		]);
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-
-export default function cursorProviderExtension(pi: CursorProviderHost): void {
-	registerCursorProvider(pi);
-}