cursor-opencode-provider 0.1.1

package/dist/models.d.ts

@@ -0,0 +1,49 @@
+export type ModelParameterValue = {
+    id: string;
+    value: string;
+};
+export type ModelVariant = {
+    key: string;
+    parameterValues: ModelParameterValue[];
+    displayName: string;
+    isDefaultNonMax: boolean;
+    isDefaultMax: boolean;
+};
+export type ModelInfo = {
+    id: string;
+    displayName?: string;
+    family?: string;
+    supportsThinking?: boolean;
+    supportsAgent?: boolean;
+    maxContext?: number;
+    supportsMaxMode?: boolean;
+    variants: ModelVariant[];
+};
+export type ModelCache = {
+    models: ModelInfo[];
+    fetchedAt: number;
+};
+export declare function isCacheFresh(cache: ModelCache, ttlMs?: number): boolean;
+export declare function cacheFilePath(configDir: string): string;
+export declare function readCache(configDir: string): Promise<ModelCache | null>;
+export declare function writeCache(configDir: string, cache: ModelCache): Promise<void>;
+export declare function mapAvailableModelsResponse(raw: Record<string, unknown>): ModelInfo[];
+/**
+ * Resolve the parameter values to send in `requested_model.parameters` for a
+ * given model + requested reasoning effort. Each variant already carries the
+ * full `{id,value}` set (per-model vocabulary), so we pick the matching variant
+ * and return its parameters verbatim — the client never constructs these by
+ * hand.
+ */
+export declare function resolveVariantParameters(model: ModelInfo | undefined, opts?: {
+    reasoningEffort?: string;
+    maxMode?: boolean;
+}): ModelParameterValue[];
+export declare function fetchModels(token: string, options?: {
+    baseURL?: string;
+    headers?: Record<string, string>;
+}): Promise<ModelInfo[]>;
+export declare function discoverModels(token: string, configDir: string, options?: {
+    baseURL?: string;
+    headers?: Record<string, string>;
+}): Promise<ModelInfo[]>;

package/dist/models.js

@@ -0,0 +1,136 @@
+import { MODEL_CACHE_FILE, MODEL_CACHE_TTL_MS } from "./shared.js";
+import { unaryAvailableModels } from "./transport/connect.js";
+import { buildRequestedModelParams } from "./protocol/thinking.js";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+// ── Cache helpers ──
+export function isCacheFresh(cache, ttlMs = MODEL_CACHE_TTL_MS) {
+    return Date.now() - cache.fetchedAt < ttlMs;
+}
+export function cacheFilePath(configDir) {
+    return path.join(configDir, MODEL_CACHE_FILE);
+}
+export async function readCache(configDir) {
+    const filePath = cacheFilePath(configDir);
+    try {
+        if (!existsSync(filePath))
+            return null;
+        const data = await readFile(filePath, "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCache(configDir, cache) {
+    const filePath = cacheFilePath(configDir);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeFile(filePath, JSON.stringify(cache, null, 2), "utf-8");
+}
+// ── Map live API response to ModelInfo[] ──
+export function mapAvailableModelsResponse(raw) {
+    const entries = raw.models ?? [];
+    const models = [];
+    for (const entry of entries) {
+        const e = entry;
+        const name = e.name;
+        if (!name)
+            continue;
+        const variants = [];
+        const rawVariants = (e.variants ?? []);
+        for (const v of rawVariants) {
+            const rawParams = (v.parameterValues ?? v.parameter_values ?? []);
+            const parameterValues = rawParams.map((p) => ({
+                id: p.id,
+                value: String(p.value ?? ""),
+            }));
+            variants.push({
+                key: name,
+                parameterValues,
+                displayName: (v.displayName ?? v.display_name ?? name),
+                isDefaultNonMax: !!(v.isDefaultNonMaxConfig ?? v.is_default_non_max_config ?? false),
+                isDefaultMax: !!(v.isDefaultMaxConfig ?? v.is_default_max_config ?? false),
+            });
+        }
+        models.push({
+            id: name,
+            displayName: (e.clientDisplayName ?? e.client_display_name ?? name),
+            supportsThinking: !!(e.supportsThinking ?? e.supports_thinking ?? false),
+            supportsAgent: !!(e.supportsAgent ?? e.supports_agent ?? false),
+            maxContext: (e.contextTokenLimit ?? e.context_token_limit ?? undefined),
+            supportsMaxMode: !!(e.supportsMaxMode ?? e.supports_max_mode ?? false),
+            variants,
+        });
+    }
+    return models;
+}
+// ── Variant resolution ──
+/**
+ * Resolve the parameter values to send in `requested_model.parameters` for a
+ * given model + requested reasoning effort. Each variant already carries the
+ * full `{id,value}` set (per-model vocabulary), so we pick the matching variant
+ * and return its parameters verbatim — the client never constructs these by
+ * hand.
+ */
+export function resolveVariantParameters(model, opts = {}) {
+    if (!model || model.variants.length === 0) {
+        // No variant metadata: fall back to a bare effort param if requested.
+        return opts.reasoningEffort ? [{ id: "effort", value: opts.reasoningEffort }] : [];
+    }
+    const effortOf = (v) => v.parameterValues.find((p) => p.id === "effort" || p.id === "reasoning")?.value;
+    const isFast = (v) => v.parameterValues.find((p) => p.id === "fast")?.value === "true";
+    const wantMax = opts.maxMode ?? false;
+    const candidates = model.variants.filter((v) => !isFast(v));
+    const pool = candidates.length > 0 ? candidates : model.variants;
+    if (opts.reasoningEffort) {
+        const match = pool.find((v) => effortOf(v) === opts.reasoningEffort);
+        if (match) {
+            return buildRequestedModelParams(match.parameterValues, {
+                reasoningEffort: opts.reasoningEffort,
+                maxMode: wantMax,
+            });
+        }
+    }
+    const byDefault = pool.find((v) => (wantMax ? v.isDefaultMax : v.isDefaultNonMax));
+    const base = (byDefault ?? pool[0]).parameterValues;
+    return buildRequestedModelParams(base, {
+        reasoningEffort: opts.reasoningEffort,
+        maxMode: wantMax,
+    });
+}
+// ── Fetch + cache orchestration ──
+export async function fetchModels(token, options = {}) {
+    const raw = await unaryAvailableModels(token, options);
+    return mapAvailableModelsResponse(raw);
+}
+export async function discoverModels(token, configDir, options = {}) {
+    const cached = await readCache(configDir);
+    // Cache is fresh → return it; refresh in background
+    if (cached && isCacheFresh(cached)) {
+        // Background refresh (fire and forget)
+        fetchModels(token, options)
+            .then((models) => writeCache(configDir, { models, fetchedAt: Date.now() }))
+            .catch(() => {
+            /* background refresh failure is non-fatal */
+        });
+        return cached.models;
+    }
+    // Cache exists but expired → try fetch, serve stale on failure
+    if (cached) {
+        try {
+            const models = await fetchModels(token, options);
+            const newCache = { models, fetchedAt: Date.now() };
+            await writeCache(configDir, newCache);
+            return models;
+        }
+        catch {
+            return cached.models;
+        }
+    }
+    // No cache → must fetch
+    const models = await fetchModels(token, options);
+    const newCache = { models, fetchedAt: Date.now() };
+    await writeCache(configDir, newCache);
+    return models;
+}

package/dist/plugin-v2.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@opencode-ai/plugin/v2/promise").Plugin;
+export default _default;

package/dist/plugin-v2.js

@@ -0,0 +1,48 @@
+import { define } from "@opencode-ai/plugin/v2/promise";
+import { CURSOR_PROVIDER_ID } from "./shared.js";
+import { createCursorLanguageModel } from "./language-model.js";
+/**
+ * OpenCode Effect / Promise v2 plugin.
+ *
+ * Wires the Cursor provider through `ctx.aisdk.sdk` / `ctx.aisdk.language`
+ * (the V2 extension points). Auth still lives in the classic Hooks plugin
+ * (`plugin.ts`) until OpenCode integrations fully replace provider OAuth.
+ */
+function isCursorPackage(pkg, providerID) {
+    if (providerID === CURSOR_PROVIDER_ID)
+        return true;
+    return (pkg.includes("cursor-opencode-provider") ||
+        /cursor-opencode-provider[/\\]dist[/\\]index\.js/.test(pkg));
+}
+function createSdk(options) {
+    const providerId = options.name || CURSOR_PROVIDER_ID;
+    return {
+        languageModel(modelId) {
+            return createCursorLanguageModel(modelId, providerId, options);
+        },
+    };
+}
+export default define({
+    id: "cursor.provider",
+    setup: async (ctx) => {
+        await ctx.aisdk.sdk((event) => {
+            if (event.sdk)
+                return;
+            if (!isCursorPackage(event.package, event.model.providerID))
+                return;
+            event.sdk = createSdk({
+                name: event.model.providerID || CURSOR_PROVIDER_ID,
+                ...event.options,
+            });
+        });
+        await ctx.aisdk.language((event) => {
+            if (event.model.providerID !== CURSOR_PROVIDER_ID)
+                return;
+            if (event.language)
+                return;
+            if (typeof event.sdk?.languageModel !== "function")
+                return;
+            event.language = event.sdk.languageModel(event.model.api.id);
+        });
+    },
+});

package/dist/plugin.d.ts

@@ -0,0 +1,2 @@
+import type { Hooks, PluginInput } from "@opencode-ai/plugin";
+export declare function CursorPlugin(input: PluginInput): Promise<Hooks>;

package/dist/plugin.js

@@ -0,0 +1,201 @@
+import { CURSOR_PROVIDER_ID, CURSOR_WEBSITE_HOST, CURSOR_API_HOST } from "./shared.js";
+import { pollForTokens, exchangeApiKey, refreshAccessToken, isExpiringSoon, generatePkceParams, generatePkceChallenge, buildLoginUrl, decodeJwtPayload } from "./auth.js";
+import { readCache, discoverModels } from "./models.js";
+const MODULE_URL = new URL("./index.js", import.meta.url).href;
+function modelInfoVariants(mi) {
+    if (mi.variants.length === 0)
+        return undefined;
+    const entries = {};
+    for (const v of mi.variants) {
+        const key = v.displayName || v.key || "default";
+        const params = {};
+        for (const p of v.parameterValues) {
+            params[p.id] = p.value;
+        }
+        entries[key] = params;
+    }
+    return entries;
+}
+function modelInfoToConfig(mi) {
+    const config = {
+        name: mi.displayName ?? mi.id,
+        reasoning: mi.supportsThinking ?? false,
+        tool_call: mi.supportsAgent ?? true,
+        temperature: false,
+        limit: {
+            context: mi.maxContext ?? 200000,
+            output: 4096,
+        },
+    };
+    const variants = modelInfoVariants(mi);
+    if (variants)
+        config.variants = variants;
+    return config;
+}
+export async function CursorPlugin(input) {
+    const configDir = process.env.CURSOR_CONFIG_DIR || input.directory;
+    async function loadModels() {
+        const cached = await readCache(configDir);
+        if (!cached || cached.models.length === 0)
+            return {};
+        const models = {};
+        for (const m of cached.models) {
+            models[m.id] = modelInfoToConfig(m);
+        }
+        return models;
+    }
+    return {
+        async config(cfg) {
+            cfg.provider ??= {};
+            const models = await loadModels();
+            const existing = cfg.provider[CURSOR_PROVIDER_ID];
+            if (existing) {
+                // Provider already declared (e.g. README stub with models: {}) —
+                // still inject the cached model list when the user hasn't filled it in.
+                const existingModels = existing.models;
+                if (!existingModels || Object.keys(existingModels).length === 0) {
+                    ;
+                    existing.models = models;
+                }
+                return;
+            }
+            cfg.provider[CURSOR_PROVIDER_ID] = {
+                name: "Cursor Integration",
+                npm: MODULE_URL,
+                models,
+            };
+        },
+        auth: {
+            provider: CURSOR_PROVIDER_ID,
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Cursor account (browser login)",
+                    async authorize() {
+                        const params = generatePkceParams();
+                        const challenge = await generatePkceChallenge(params.verifier);
+                        const websiteUrl = process.env.CURSOR_WEBSITE_URL ?? `https://${CURSOR_WEBSITE_HOST}`;
+                        const apiBaseUrl = process.env.CURSOR_API_BASE_URL ?? `https://${CURSOR_API_HOST}`;
+                        const url = buildLoginUrl(challenge, params.uuid, websiteUrl);
+                        return {
+                            url,
+                            instructions: "Open this URL in a browser to sign in to Cursor",
+                            method: "auto",
+                            async callback() {
+                                const result = await pollForTokens(params.uuid, params.verifier, apiBaseUrl);
+                                return {
+                                    type: "success",
+                                    provider: CURSOR_PROVIDER_ID,
+                                    access: result.accessToken,
+                                    refresh: result.refreshToken,
+                                    expires: decodeExpFromJwt(result.accessToken),
+                                };
+                            },
+                        };
+                    },
+                },
+                {
+                    type: "api",
+                    label: "API key (cursor.com/settings)",
+                    prompts: [
+                        {
+                            type: "text",
+                            key: "apiKey",
+                            message: "Cursor API key",
+                            placeholder: "sk-...",
+                            validate(value) {
+                                if (!value.startsWith("sk-"))
+                                    return "API key should start with sk-";
+                                return undefined;
+                            },
+                        },
+                    ],
+                    async authorize(inputs) {
+                        const apiKey = inputs?.apiKey;
+                        if (!apiKey)
+                            return { type: "failed" };
+                        try {
+                            const result = await exchangeApiKey(apiKey);
+                            return {
+                                type: "success",
+                                key: result.accessToken,
+                                provider: CURSOR_PROVIDER_ID,
+                                metadata: { refreshToken: result.refreshToken },
+                            };
+                        }
+                        catch {
+                            return { type: "failed" };
+                        }
+                    },
+                },
+            ],
+            async loader(getAuth) {
+                const auth = await getAuth();
+                if (!auth)
+                    return {};
+                let accessToken;
+                if (auth.type === "api") {
+                    accessToken = auth.key;
+                    const refreshToken = auth.metadata?.refreshToken;
+                    // API-key exchange returns a short-lived JWT stored as `key`. Refresh
+                    // it the same way as OAuth when it is expiring / already expired.
+                    if (refreshToken && isExpiringSoon(auth.key)) {
+                        try {
+                            const newTokens = await refreshAccessToken(refreshToken);
+                            await input.client.auth.set({
+                                path: { id: CURSOR_PROVIDER_ID },
+                                body: {
+                                    type: "api",
+                                    key: newTokens.accessToken,
+                                    metadata: { refreshToken: newTokens.refreshToken },
+                                },
+                            });
+                            accessToken = newTokens.accessToken;
+                        }
+                        catch {
+                            // refresh failed — keep the existing key; the next call may still work
+                        }
+                    }
+                }
+                else if (auth.type === "oauth") {
+                    if (!isExpiringSoon(auth.access)) {
+                        accessToken = auth.access;
+                    }
+                    else if (auth.refresh) {
+                        try {
+                            const newTokens = await refreshAccessToken(auth.refresh);
+                            await input.client.auth.set({
+                                path: { id: CURSOR_PROVIDER_ID },
+                                body: {
+                                    type: "oauth",
+                                    access: newTokens.accessToken,
+                                    refresh: newTokens.refreshToken,
+                                    expires: decodeExpFromJwt(newTokens.accessToken),
+                                },
+                            });
+                            accessToken = newTokens.accessToken;
+                        }
+                        catch {
+                            // refresh failed
+                        }
+                    }
+                }
+                if (accessToken) {
+                    // Use discoverModels so we respect TTL / serve-stale semantics and
+                    // write through the same cache path language-model reads.
+                    discoverModels(accessToken, configDir).catch(() => { });
+                }
+                return {
+                    ...(accessToken ? { accessToken } : {}),
+                    workspaceRoot: input.directory,
+                };
+            },
+        },
+    };
+}
+function decodeExpFromJwt(jwt) {
+    const payload = decodeJwtPayload(jwt);
+    if (payload && typeof payload.exp === "number")
+        return payload.exp * 1000;
+    return Date.now() + 3600_000;
+}

package/dist/protocol/blob-store.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Cursor CLI keeps conversation blobs in a durable client store (SQLite) across
+ * Runs. ConversationStateStructure only holds blob IDs; the server re-fetches
+ * them via get_blob on the next turn. Our per-Run session.blobs Map was wiped
+ * on stream close, so follow-up gets echoed 32-byte hashes → server JSON.parse
+ * fails ("Unexpected token ... is not valid JSON").
+ *
+ * This store is keyed by conversation_id and survives across Run streams.
+ */
+export declare function setConversationBlob(conversationId: string, blobId: Uint8Array, blobData: Uint8Array): string;
+export declare function getConversationBlob(conversationId: string, blobId: Uint8Array): Uint8Array | undefined;
+export declare function conversationBlobCount(conversationId: string): number;
+/** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
+export declare function isBlobIdHash(blobId: Uint8Array): boolean;
+export declare function resetConversationBlobsForTests(): void;

package/dist/protocol/blob-store.js

@@ -0,0 +1,52 @@
+/**
+ * Cursor CLI keeps conversation blobs in a durable client store (SQLite) across
+ * Runs. ConversationStateStructure only holds blob IDs; the server re-fetches
+ * them via get_blob on the next turn. Our per-Run session.blobs Map was wiped
+ * on stream close, so follow-up gets echoed 32-byte hashes → server JSON.parse
+ * fails ("Unexpected token ... is not valid JSON").
+ *
+ * This store is keyed by conversation_id and survives across Run streams.
+ */
+function hex(b) {
+    let s = "";
+    for (let i = 0; i < b.length; i++)
+        s += b[i].toString(16).padStart(2, "0");
+    return s;
+}
+const byConversation = new Map();
+function bucket(conversationId) {
+    let m = byConversation.get(conversationId);
+    if (!m) {
+        m = new Map();
+        byConversation.set(conversationId, m);
+    }
+    return m;
+}
+export function setConversationBlob(conversationId, blobId, blobData) {
+    const key = hex(blobId);
+    // Copy so decode buffers can't mutate the store later.
+    bucket(conversationId).set(key, Uint8Array.from(blobData));
+    return key;
+}
+export function getConversationBlob(conversationId, blobId) {
+    return bucket(conversationId).get(hex(blobId));
+}
+export function conversationBlobCount(conversationId) {
+    return byConversation.get(conversationId)?.size ?? 0;
+}
+/** SHA-256 content hashes are 32 non-text bytes — never echo those as content. */
+export function isBlobIdHash(blobId) {
+    if (blobId.length !== 32)
+        return false;
+    // Content-as-id payloads can also be 32 bytes (short JSON). Real hashes are
+    // binary; if every byte is printable ASCII/UTF-8 text, treat as content.
+    for (let i = 0; i < blobId.length; i++) {
+        const b = blobId[i];
+        if (b < 0x09 || (b > 0x0d && b < 0x20) || b > 0x7e)
+            return true;
+    }
+    return false;
+}
+export function resetConversationBlobsForTests() {
+    byConversation.clear();
+}

package/dist/protocol/checkpoint.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cursor CLI parity: the server emits `conversation_checkpoint_update` after
+ * (and during) a turn. The CLI replaces its local ConversationStateStructure
+ * and re-sends that structure as `AgentRunRequest.conversation_state` on the
+ * next Run. We mirror that with an in-process store keyed by conversation_id.
+ *
+ * Checkpoints are kept as opaque protobuf bytes — CLI's structure uses blob-id
+ * fields (repeated bytes), not the seed JSON strings we invent on turn 1.
+ */
+/** Replace the stored checkpoint for a conversation (CLI handleCheckpoint). */
+export declare function setCheckpoint(conversationId: string, bytes: Uint8Array): void;
+/** Last checkpoint for this conversation, if any. */
+export declare function getCheckpoint(conversationId: string): Uint8Array | undefined;
+/** Drop a conversation's checkpoint (tests / explicit reset). */
+export declare function clearCheckpoint(conversationId: string): void;
+/** Test helper — wipe all stored checkpoints. */
+export declare function resetCheckpointsForTests(): void;

package/dist/protocol/checkpoint.js

@@ -0,0 +1,29 @@
+/**
+ * Cursor CLI parity: the server emits `conversation_checkpoint_update` after
+ * (and during) a turn. The CLI replaces its local ConversationStateStructure
+ * and re-sends that structure as `AgentRunRequest.conversation_state` on the
+ * next Run. We mirror that with an in-process store keyed by conversation_id.
+ *
+ * Checkpoints are kept as opaque protobuf bytes — CLI's structure uses blob-id
+ * fields (repeated bytes), not the seed JSON strings we invent on turn 1.
+ */
+const byConversationId = new Map();
+/** Replace the stored checkpoint for a conversation (CLI handleCheckpoint). */
+export function setCheckpoint(conversationId, bytes) {
+    if (!conversationId || bytes.length === 0)
+        return;
+    // Copy so later mutations of the decode buffer can't corrupt the store.
+    byConversationId.set(conversationId, Uint8Array.from(bytes));
+}
+/** Last checkpoint for this conversation, if any. */
+export function getCheckpoint(conversationId) {
+    return byConversationId.get(conversationId);
+}
+/** Drop a conversation's checkpoint (tests / explicit reset). */
+export function clearCheckpoint(conversationId) {
+    byConversationId.delete(conversationId);
+}
+/** Test helper — wipe all stored checkpoints. */
+export function resetCheckpointsForTests() {
+    byConversationId.clear();
+}

package/dist/protocol/checksum.d.ts

@@ -0,0 +1,2 @@
+export declare function obfuscate(bytes: Uint8Array): Uint8Array;
+export declare function createCursorChecksumHeader(machineId: string, macMachineId?: string): string;

package/dist/protocol/checksum.js

@@ -0,0 +1,23 @@
+export function obfuscate(bytes) {
+    const out = new Uint8Array(bytes);
+    let a = 165;
+    for (let i = 0; i < out.length; i++) {
+        out[i] = ((out[i] ^ a) + i) & 0xff;
+        a = out[i];
+    }
+    return out;
+}
+export function createCursorChecksumHeader(machineId, macMachineId) {
+    const n = Math.floor(Date.now() / 1e6);
+    const ts = new Uint8Array([
+        (n >> 40) & 0xff,
+        (n >> 32) & 0xff,
+        (n >> 24) & 0xff,
+        (n >> 16) & 0xff,
+        (n >> 8) & 0xff,
+        n & 0xff,
+    ]);
+    const obfuscated = obfuscate(ts);
+    const prefix = btoa(String.fromCharCode(...obfuscated)).replace(/=+$/, "");
+    return macMachineId ? `${prefix}${machineId}/${macMachineId}` : `${prefix}${machineId}`;
+}

package/dist/protocol/client-version.d.ts

@@ -0,0 +1,5 @@
+export declare function resetClientVersionCache(): void;
+export declare function resolveClientVersion(): Promise<string>;
+export declare function cursorAgentVersionsDir(): string | undefined;
+export declare function discoverLocalVersion(dir?: string | undefined): string | undefined;
+export declare function extractVersionFromInstaller(script: string): string | undefined;