@vidit19sharma/opencode-cursor-auth 0.0.0-stage → 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,32 @@
+# Changelog
+
+All notable changes to this project are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## 0.2.0 — 2026-10-16
+
+### Added
+
+- Model variants: every variant Cursor publishes (reasoning effort, fast, 1M context) is a selectable id, e.g. `cursor/gpt-5.5-low-fast`, `cursor/claude-opus-5-5-1m-max`. Ids are the base id plus non-default param values and map back to Cursor `ModelSelection` params; unknown ids still pass through to Cursor's own 400.
+- Model context limits: each model gets `limit.context` from Cursor's `context` parameter (default 200k) and `limit.output` 32k. Without a limit opencode 1.19 sets context to 0 and silently disables auto-compaction and the context indicator.
+- SDK key check on `/chat/completions` (60s cache, skipped for pasted/env keys): a missing or expired key returns 401 telling the user to run `opencode auth login`; one-time stderr warning within 7 days of expiry.
+- Concurrency cap: a FIFO semaphore limits concurrently active Cursor runs (default 4, `OPENCODE_CURSOR_MAX_ACTIVE` to override). Extra requests queue; tool-result continuations never take a slot.
+- Retry: `Agent.create` / `Agent.resume` / `send` are attempted up to 3 times with jittered backoff on 429, 5xx, and network errors; never after the first byte.
+- Usage reports cache-read tokens (`prompt_tokens_details.cached_tokens`) and reasoning tokens (`completion_tokens_details.reasoning_tokens`).
+
+### Changed
+
+- Models cache bumped to v3 `{name, context, params}`; older cache files are refetched once. Catalog code moved to `src/models.ts`.
+- The reply is opened only on content deltas (text/thinking), so run errors before any content become real JSON error responses instead of a 200 stream with an error frame.
+
+### Fixed
+
+- Real HTTP error statuses: failures before the first byte return a JSON error with a real status (400 bad model/argument, 401 auth, 403 blocked, 429 rate limit, 502 otherwise); mid-stream failures emit an OpenAI error frame and close without `[DONE]`.
+- Admin-blocked models: "Model Blocked" / `permission_denied` map to 403 `permission_error` and are never retried. A 403 marks the model and its variants blocked in the models cache; they are hidden from the model list until the next 24h catalog refresh and still resolve if used explicitly.
+- Abort propagation: the request AbortSignal and stream `cancel()` cancel the Cursor run, close the agent, and release registries (no more zombie runs burning usage).
+- agentId race: the held run is registered before `send()`, so a tool call firing immediately can never miss its continuation lookup.
+- Session resume is scoped by opencode session id (via the `chat.headers` hook), so byte-identical histories from different sessions (parallel sub-agents) never resume each other's Cursor agent. Unscoped callers and existing disk entries hash exactly as before.
+- Per-session temp workspaces are removed once no session, disk, or held entry references them.
+
+## 0.1.0 — 2026-10-15
+
+- Initial release: in-process Cursor SDK bridge, auth, tool loop, session resume, AGENTS.md system prompt, dynamic model list.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vidit Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,144 @@
-# Temporary Holding Version
+# opencode-cursor-auth
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Use your **Cursor subscription** inside [opencode](https://opencode.ai) — no proxy server, no port, no separate API bill.
+
+The plugin bridges opencode's OpenAI-style chat requests to the official [`@cursor/sdk`](https://www.npmjs.com/package/@cursor/sdk) **in-process**, so every model your Cursor plan includes (GPT, Claude, Gemini, Kimi, GLM, Composer, …) shows up as a `cursor/*` model in opencode.
+
+## Features
+
+- **Official SDK, not a reverse-engineered API** — auth, checksums, and client versioning handled by `@cursor/sdk`
+- **In-process bridge** — no local HTTP proxy, no port to collide on, no extra daemon
+- **Full tool loop** — opencode's native tools (read, edit, bash, MCP, …) work end-to-end via a held-run bridge: one Cursor run spans the whole tool exchange
+- **Thinking blocks** — Cursor reasoning streams into opencode as proper thinking blocks (`reasoning_content`)
+- **Session resume** — conversations map to native Cursor agents (`Agent.resume`), in-memory and persisted to disk for 7 days, scoped per opencode session so parallel sub-agents never share an agent
+- **System prompts** — delivered via `AGENTS.md` in a per-session workspace (the `--system-prompt` flag is server-gated by Cursor)
+- **Dynamic model list with variants** — fetched live from `Cursor.models.list()`, cached 24h; every reasoning-effort / fast / 1M-context variant is its own model id
+- **Context limits** — each model publishes its Cursor context window, so opencode's auto-compaction and context indicator work
+- **Real error statuses** — 400 / 401 / 403 / 429 / 502 instead of a 200 stream carrying an error
+- **Cancellation** — Esc or a sub-agent timeout cancels the Cursor run and closes the agent
+- **Concurrency cap and retry** — at most 4 Cursor runs at once (configurable); transient failures retried before the first byte
+- **Usage** — prompt, completion, cached-read, and reasoning tokens reported to opencode
+- **Zero cost display** — models are marked cost-free since you're on subscription billing
+
+## Requirements
+
+- Node >= 22.13 (opencode runs plugins on Bun, which also works)
+- [`cursor-agent` CLI](https://cursor.com/docs/cli) installed (`curl https://cursor.com/install -fsS | bash`) — the SDK's local executor uses it
+- A Cursor subscription
+
+## Install
+
+Add the plugin to `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugin": ["@vidit19sharma/opencode-cursor-auth@latest"]
+}
+```
+
+The plugin auto-registers a `cursor` provider — no manual provider config needed.
+
+## Authenticate
+
+```sh
+opencode auth login
+```
+
+Pick **Cursor**, then either:
+
+- **Log in with Cursor (browser)** — opens cursor.com, mints a 90-day SDK key, stored at `~/.cursor/sdk/auth.json`
+- **Paste a Cursor API key** — from [cursor.com/dashboard](https://cursor.com/dashboard)
+
+Alternatively set `CURSOR_API_KEY` in your environment.
+
+When the browser-login key is used, the plugin checks it before each request (cached 60s): a missing or expired key returns a 401 telling you to run `opencode auth login`, and a one-time warning is printed to stderr within 7 days of expiry. The check is skipped for pasted keys and `CURSOR_API_KEY`.
+
+## Use
+
+```sh
+opencode run -m cursor/gpt-5.5 "hello"
+opencode run -m cursor/claude-opus-5-5 "hello"
+opencode run -m cursor/auto "hello"
+```
+
+Or pick any `cursor/*` model from the opencode model selector.
+
+## Models
+
+```sh
+opencode models | grep cursor/
+```
+
+- **Base ids** (`cursor/gpt-5.5`) send no parameters, so Cursor applies its own defaults. Cursor's `default` model is exposed as `cursor/auto`.
+- **Variant ids** are the base id plus every non-default parameter value, in Cursor's parameter order. Boolean parameters use the parameter name. Examples: `cursor/gpt-5.5-low`, `cursor/gpt-5.5-high-fast`, `cursor/gpt-5.5-1m-extra-high`, `cursor/claude-opus-5-5-1m-max`.
+- The full catalog is currently about 485 ids from 47 models.
+- **Limits**: `limit.context` is the variant's context value, else the model's first listed context value, else 200k. `limit.output` is a fixed 32k accounting reserve (Cursor publishes no output cap and the bridge sends no `max_tokens`). Limits you set yourself in opencode config are kept.
+- **Unknown ids** are passed through to Cursor, which answers with its own 400.
+- **Blocked models**: Cursor's catalog has no per-account entitlement info. If Cursor rejects a model as "Model Blocked" (e.g. a team admin disabled it), the request fails with 403 `permission_error` carrying Cursor's message, and that model and all its variants are hidden from the list. Using a hidden id explicitly still sends it to Cursor. Blocked flags persist across catalog refreshes; delete `~/.cache/opencode-cursor-auth/models.json` to re-check.
+- **Offline / logged out**: the stale cache is used if present, otherwise only `cursor/auto`.
+
+The catalog is cached at `~/.cache/opencode-cursor-auth/models.json`; delete it to force a refresh.
+
+## Configuration
+
+| Setting | Default | Purpose |
+| --- | --- | --- |
+| `OPENCODE_CURSOR_MAX_ACTIVE` | `4` | Max Cursor runs active at once; extra requests queue FIFO |
+| `CURSOR_API_KEY` | unset | Use this key instead of the stored SDK key |
+
+| Path | Contents |
+| --- | --- |
+| `~/.cursor/sdk/auth.json` | 90-day SDK key from browser login (written by `@cursor/sdk`) |
+| `~/.cache/opencode-cursor-auth/models.json` | Model catalog, 24h TTL, blocked-model flags |
+| `~/.cache/opencode-cursor-auth/sessions.json` | Conversation → Cursor agent map, 7-day TTL |
+
+## How it works
+
+```
+opencode ──(OpenAI chat JSON)──> plugin fetch() ──> @cursor/sdk Agent ──> cursor-agent ──> Cursor backend
+         <─(SSE stream)────────  bridge  <──(typed deltas: text / thinking / tool calls)
+```
+
+- opencode calls the provider's `fetch` — the plugin intercepts it in-process; `http://cursor.local/v1` is a dummy URL that never resolves.
+- Each opencode tool is registered as a Cursor **custom tool** whose `execute()` parks a promise, emits an OpenAI `tool_calls` chunk, and resumes the *same* Cursor run when opencode sends the tool result back.
+- Conversation prefixes, plus the opencode session id (sent via the `chat.headers` hook), are hashed → mapped to Cursor agent IDs, so follow-up turns use `Agent.resume` instead of replaying history. The map persists at `~/.cache/opencode-cursor-auth/sessions.json`.
+- System messages are written to `AGENTS.md` in a per-session temp workspace and loaded via Cursor's project rules (`settingSources: ["project"]`). Workspaces are removed once no session references them.
+- Variant ids are mapped back to Cursor `ModelSelection` params (`{ id, params }`).
+- New turns take a slot from a FIFO semaphore (`OPENCODE_CURSOR_MAX_ACTIVE`); tool-result continuations reuse their run's slot. `Agent.create` / `Agent.resume` / `send` are attempted up to 3 times with jittered exponential backoff on 429, 5xx, and network errors, never after the first byte.
+- The HTTP reply opens on the first text or thinking delta, so failures before any content become real HTTP errors.
+- The request's abort signal and stream cancel cancel the Cursor run, close the agent, and release its slot.
+
+### Errors
+
+| Status | When |
+| --- | --- |
+| 400 | Unknown model or bad argument (Cursor's message); also an expired tool-call continuation |
+| 401 | SDK key missing/expired, or Cursor rejects the key |
+| 403 | Model blocked for your account (`permission_error`) |
+| 429 | Cursor rate limit |
+| 502 | Anything else |
+
+These are JSON error responses when the failure happens before the first byte; mid-stream failures emit an SSE `error` frame and close the stream without `[DONE]`.
+
+## Development
+
+```sh
+bun install
+bun run build        # tsc → dist/
+bun run test         # end-to-end bridge tests (requires Cursor login, uses real Cursor usage)
+bun run spike        # raw @cursor/sdk validation
+```
+
+The test suite runs 13 scenarios: plain streaming, a full tool loop on one held run, in-memory and disk-persisted session resume, AGENTS.md system-prompt delivery, mid-stream abort, error statuses, session scoping, context limits and key checks, model variants, the concurrency cap, retry semantics, and blocked models.
+
+## Known limitations
+
+- `systemPrompt` as a true harness replacement is feature-gated server-side by Cursor; system text is applied via `AGENTS.md` as a project rule (merged under Cursor's harness prompt).
+- The SDK spawns a `cursor-agent` worker per turn (~1–2 s startup on resume).
+- The model list is Cursor's full catalog (~485 ids). It has no entitlement info, so models your plan or team blocks only disappear after the first 403.
+- A run parked waiting for a tool result keeps its slot. Cursor-model sessions that spawn Cursor-model sub-agents nested deeper than `OPENCODE_CURSOR_MAX_ACTIVE` will stall; raise the limit if you fan out.
+- Usage/rate limits are whatever your Cursor plan enforces — the plugin adds none beyond the concurrency cap.
+
+## License
+
+[MIT](./LICENSE) © Vidit Sharma

package/dist/bridge.d.ts

@@ -0,0 +1,45 @@
+type ContentPart = {
+    type: string;
+    text?: string;
+};
+type OaMessage = {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string | ContentPart[] | null;
+    tool_calls?: {
+        id: string;
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[];
+    tool_call_id?: string;
+};
+type OaTool = {
+    type: "function";
+    function: {
+        name: string;
+        description?: string;
+        parameters?: Record<string, unknown>;
+    };
+};
+type OaBody = {
+    model: string;
+    messages: OaMessage[];
+    tools?: OaTool[];
+    stream?: boolean;
+};
+export declare function isTransient(err: unknown): boolean;
+export declare function withRetry<T>(fn: () => Promise<T>, signal?: AbortSignal, baseDelayMs?: number, retryable?: typeof isTransient): Promise<T>;
+export declare function _setMaxActive(n: number): void;
+export declare function errorResponse(err: unknown, status?: number): Response;
+export declare function _resetForTest(): void;
+export declare function _stats(): {
+    held: number;
+    sessions: number;
+    disk: number;
+    agentIds: string[];
+    active: number;
+    waiting: number;
+};
+export declare function handleChatCompletion(body: OaBody, apiKey?: string, signal?: AbortSignal, scope?: string): Promise<Response>;
+export {};

package/dist/bridge.js

@@ -0,0 +1,717 @@
+/**
+ * OpenAI chat-completions JSON <-> @cursor/sdk bridge, fully in-process.
+ *
+ * Tool loop ("held run" pattern, from pwnapplehat/Cursor-OpenAI):
+ * each opencode tool is registered as a Cursor customTool whose execute()
+ * PARKS on a promise. When the model requests tools we flush them to the
+ * client as OpenAI tool_calls and keep the Cursor run alive. The client's
+ * next HTTP request (role:"tool" messages) resolves the parked promises and
+ * the SAME run continues — one metered Cursor run per opencode tool loop.
+ */
+import { Agent, AuthenticationError, ConfigurationError, NetworkError, RateLimitError } from "@cursor/sdk";
+import { createHash, randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtemp, readFile, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { markBlocked, resolveModel } from "./models.js";
+// @cursor/sdk's internal logger writes "HH:MM:SS.mmm INFO ..." lines via
+// console.log unconditionally (no config/env to silence it, verified against
+// the esm bundle). Filter exactly those lines, pass everything else through.
+const SDK_LOG_LINE = /^\d{2}:\d{2}:\d{2}\.\d{3} (TRACE|DEBUG|INFO|WARN|ERROR)\s/;
+const originalConsoleLog = console.log.bind(console);
+console.log = (...args) => {
+    if (typeof args[0] === "string" && SDK_LOG_LINE.test(args[0]))
+        return;
+    originalConsoleLog(...args);
+};
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!content)
+        return "";
+    return content.map((p) => p.text ?? "").join("");
+}
+function statusFor(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    const msg = String(e.message ?? err ?? "");
+    const code = typeof e.code === "string" ? e.code : "";
+    if (err instanceof AuthenticationError || e.status === 401 || code === "unauthenticated" || /invalid user api key/i.test(msg))
+        return 401;
+    if (err instanceof RateLimitError || e.status === 429 || code === "resource_exhausted" || /rate limit/i.test(msg))
+        return 429;
+    if (code === "permission_denied" || /model blocked|permission denied|forbidden/i.test(msg))
+        return 403;
+    if (err instanceof ConfigurationError || code === "invalid_argument" || code === "not_found" || /cannot use this model|unknown model/i.test(msg))
+        return 400;
+    return 502;
+}
+const ERROR_TYPE = {
+    400: "invalid_request_error",
+    401: "authentication_error",
+    403: "permission_error",
+    429: "rate_limit_error",
+};
+function errorBody(err, status = statusFor(err)) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    return {
+        error: {
+            message: String(e.message ?? err ?? "unknown error"),
+            type: ERROR_TYPE[status] ?? "api_error",
+            ...(typeof e.code === "string" ? { code: e.code } : {}),
+        },
+    };
+}
+const abortError = () => new DOMException("aborted", "AbortError");
+export function isTransient(err) {
+    const e = (typeof err === "object" && err !== null ? err : {});
+    if (e.name === "AbortError")
+        return false;
+    const status = statusFor(err);
+    if (status === 429)
+        return true;
+    if (status === 400 || status === 401 || status === 403 || e.status === 404)
+        return false;
+    if (err instanceof NetworkError || (typeof e.status === "number" && e.status >= 500))
+        return true;
+    return /unavailable|deadline_exceeded|ECONNRESET|ETIMEDOUT|fetch failed/i.test(`${e.code ?? ""} ${e.message ?? ""}`);
+}
+export async function withRetry(fn, signal, baseDelayMs = 1000, retryable = isTransient) {
+    for (let attempt = 0;; attempt++) {
+        if (signal?.aborted)
+            throw abortError();
+        try {
+            return await fn();
+        }
+        catch (err) {
+            if (attempt >= 2 || signal?.aborted || !retryable(err))
+                throw err;
+            const delay = Math.min(baseDelayMs * 2 ** attempt * (0.75 + Math.random() * 0.5), 30_000);
+            await new Promise((r) => {
+                const t = setTimeout(r, delay);
+                signal?.addEventListener("abort", () => (clearTimeout(t), r(undefined)), { once: true });
+            });
+        }
+    }
+}
+// ponytail: global semaphore, slot held across parked tool loops; per-session fairness if it ever matters
+let maxActive = Number(process.env.OPENCODE_CURSOR_MAX_ACTIVE) || 4;
+let active = 0;
+const waiters = [];
+function pump() {
+    while (active < maxActive && waiters.length) {
+        active++;
+        waiters.shift()();
+    }
+}
+function acquireSlot(signal) {
+    if (signal?.aborted)
+        return Promise.reject(abortError());
+    if (active < maxActive && !waiters.length) {
+        active++;
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        const onAbort = () => {
+            const i = waiters.indexOf(go);
+            if (i >= 0)
+                waiters.splice(i, 1);
+            reject(abortError());
+        };
+        const go = () => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve();
+        };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        waiters.push(go);
+    });
+}
+function releaseSlot() {
+    active--;
+    pump();
+}
+export function _setMaxActive(n) {
+    maxActive = n;
+    pump();
+}
+export function errorResponse(err, status = statusFor(err)) {
+    return Response.json(errorBody(err, status), { status });
+}
+function chunk(id, model, delta, finish, usage) {
+    return {
+        id,
+        object: "chat.completion.chunk",
+        created: Math.floor(Date.now() / 1000),
+        model,
+        choices: [{ index: 0, delta, finish_reason: finish }],
+        ...(usage ? { usage } : {}),
+    };
+}
+function sseResponse(model, onCancel) {
+    const id = `chatcmpl-${randomUUID()}`;
+    const enc = new TextEncoder();
+    let controller;
+    let closed = false;
+    const stream = new ReadableStream({
+        start(c) {
+            controller = c;
+            send({ role: "assistant", content: "" });
+        },
+        cancel() {
+            closed = true;
+            onCancel();
+        },
+    });
+    function frame(payload) {
+        if (closed)
+            return;
+        controller.enqueue(enc.encode(`data: ${JSON.stringify(payload)}\n\n`));
+    }
+    function send(delta, finish = null, usage) {
+        frame(chunk(id, model, delta, finish, usage));
+    }
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        try {
+            controller.close();
+        }
+        catch { }
+    }
+    function end() {
+        if (closed)
+            return;
+        controller.enqueue(enc.encode("data: [DONE]\n\n"));
+        close();
+    }
+    const sink = {
+        text: (t) => send({ content: t }),
+        reasoning: (t) => send({ reasoning_content: t }),
+        toolCalls: (calls) => send({
+            tool_calls: calls.map((c, index) => ({
+                index,
+                id: c.id,
+                type: "function",
+                function: { name: c.name, arguments: c.argumentsJson },
+            })),
+        }),
+        finish: (reason, usage) => {
+            send({}, reason, usage);
+            end();
+        },
+        fail: (err) => {
+            frame(errorBody(err));
+            close();
+        },
+        close,
+    };
+    return {
+        response: new Response(stream, {
+            status: 200,
+            headers: { "content-type": "text/event-stream", "cache-control": "no-cache" },
+        }),
+        sink,
+    };
+}
+function jsonCollector(model, resolve) {
+    const id = `chatcmpl-${randomUUID()}`;
+    let content = "";
+    let calls = [];
+    return {
+        text: (t) => (content += t),
+        reasoning: () => { },
+        toolCalls: (c) => (calls = calls.concat(c)),
+        finish: (reason, usage) => resolve(Response.json({
+            id,
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model,
+            choices: [
+                {
+                    index: 0,
+                    message: {
+                        role: "assistant",
+                        content: content || null,
+                        ...(calls.length
+                            ? {
+                                tool_calls: calls.map((c2) => ({
+                                    id: c2.id,
+                                    type: "function",
+                                    function: { name: c2.name, arguments: c2.argumentsJson },
+                                })),
+                            }
+                            : {}),
+                    },
+                    finish_reason: reason,
+                },
+            ],
+            usage: usage ?? { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+        })),
+        fail: (err) => resolve(errorResponse(err)),
+        close: () => { },
+    };
+}
+function deferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    return { promise, resolve, reject };
+}
+const BATCH_SETTLE_MS = 300;
+const TOOL_RESULT_TIMEOUT_MS = 10 * 60 * 1000;
+const SESSION_TTL_MS = 30 * 60 * 1000;
+const DISK_SESSION_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+// ponytail: single-user plugin, small fixed caps; make configurable if ever shared
+const MAX_SESSIONS = 8;
+const SESSION_STORE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
+const SESSION_STORE_PATH = join(SESSION_STORE_DIR, "sessions.json");
+const TMP_CWD_PREFIX = join(tmpdir(), "opencode-cursor-");
+const sessions = new Map();
+const heldByAgent = new Map();
+const agentByToolCallId = new Map();
+let diskSessions = new Map();
+let sessionsLoaded = false;
+// ponytail: no orphan sweep, other opencode instances may own those dirs
+function releaseCwd(cwd) {
+    if (!cwd.startsWith(TMP_CWD_PREFIX))
+        return;
+    for (const v of sessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const v of diskSessions.values())
+        if (v.cwd === cwd)
+            return;
+    for (const h of heldByAgent.values())
+        if (h.cwd === cwd)
+            return;
+    rmSync(cwd, { recursive: true, force: true });
+}
+// scope (opencode session id) is folded in so identical histories from
+// different sessions (e.g. parallel sub-agents) never share a Cursor agent
+function hashMessages(messages, scope) {
+    const norm = messages.map((m) => [m.role, textOf(m.content), m.tool_call_id ?? "", JSON.stringify(m.tool_calls ?? null)]);
+    if (scope)
+        norm.unshift(["scope", scope]);
+    return createHash("sha256").update(JSON.stringify(norm)).digest("hex");
+}
+function collectDiskEntries() {
+    const now = Date.now();
+    const entries = {};
+    for (const [k, v] of diskSessions)
+        if (now - v.lastUsedAt <= DISK_SESSION_TTL_MS)
+            entries[k] = v;
+    return entries;
+}
+async function loadSessions() {
+    if (sessionsLoaded)
+        return;
+    sessionsLoaded = true;
+    try {
+        const raw = JSON.parse(await readFile(SESSION_STORE_PATH, "utf8"));
+        if (raw.version !== 1 || !raw.entries)
+            return;
+        const now = Date.now();
+        for (const [k, v] of Object.entries(raw.entries)) {
+            // disk entries stay out of the 30-min memory map so the memory sweep
+            // can't evict a still-valid 7-day entry; lookup falls back to diskSessions
+            if (now - v.lastUsedAt <= DISK_SESSION_TTL_MS)
+                diskSessions.set(k, v);
+        }
+        for (const v of Object.values(raw.entries))
+            if (now - v.lastUsedAt > DISK_SESSION_TTL_MS)
+                releaseCwd(v.cwd);
+    }
+    catch { }
+}
+function saveSessions() {
+    mkdirSync(SESSION_STORE_DIR, { recursive: true });
+    writeFileSync(SESSION_STORE_PATH, JSON.stringify({ version: 1, entries: collectDiskEntries() }));
+}
+function sweepSessions(save = true) {
+    const now = Date.now();
+    const evicted = [];
+    for (const [k, v] of diskSessions)
+        if (now - v.lastUsedAt > DISK_SESSION_TTL_MS) {
+            diskSessions.delete(k);
+            evicted.push(v.cwd);
+        }
+    for (const [k, v] of sessions)
+        if (now - v.lastUsedAt > SESSION_TTL_MS) {
+            sessions.delete(k);
+            evicted.push(v.cwd);
+        }
+    while (sessions.size > MAX_SESSIONS) {
+        let oldestKey = "";
+        let oldest = Infinity;
+        for (const [k, v] of sessions)
+            if (v.lastUsedAt < oldest) {
+                oldest = v.lastUsedAt;
+                oldestKey = k;
+            }
+        evicted.push(sessions.get(oldestKey).cwd);
+        sessions.delete(oldestKey);
+    }
+    for (const cwd of evicted)
+        releaseCwd(cwd);
+    if (save)
+        saveSessions();
+}
+/**
+ * Re-key the session under the conversation state the NEXT request will
+ * present (current messages + the assistant message we just produced), since
+ * session-unaware clients like opencode resend full history every turn.
+ */
+function rememberSession(held, toolCalls) {
+    const assistant = {
+        role: "assistant",
+        content: held.textAcc || null,
+        ...(toolCalls.length
+            ? { tool_calls: toolCalls.map((c) => ({ id: c.id, function: { name: c.name, arguments: c.argumentsJson } })) }
+            : {}),
+    };
+    const key = hashMessages(held.messages.concat(assistant), held.scope);
+    const entry = {
+        agentId: held.agent.agentId,
+        cwd: held.cwd,
+        lastUsedAt: Date.now(),
+    };
+    const displaced = sessions.get(key) ?? diskSessions.get(key);
+    sessions.set(key, entry);
+    diskSessions.set(key, entry);
+    sweepSessions();
+    if (displaced && displaced.cwd !== entry.cwd)
+        releaseCwd(displaced.cwd);
+}
+async function syncAgentsMd(cwd, messages) {
+    mkdirSync(cwd, { recursive: true });
+    const path = join(cwd, "AGENTS.md");
+    const systemText = messages
+        .filter((m) => m.role === "system")
+        .map((m) => textOf(m.content))
+        .filter(Boolean)
+        .join("\n\n");
+    if (systemText)
+        await writeFile(path, systemText);
+    else if (existsSync(path))
+        rmSync(path);
+}
+function mapUsage(u) {
+    if (!u)
+        return undefined;
+    const prompt = u.inputTokens ?? 0;
+    const completion = u.outputTokens ?? 0;
+    const usage = { prompt_tokens: prompt, completion_tokens: completion, total_tokens: prompt + completion };
+    if (u.cacheReadTokens)
+        usage.prompt_tokens_details = { cached_tokens: u.cacheReadTokens };
+    if (u.reasoningTokens)
+        usage.completion_tokens_details = { reasoning_tokens: u.reasoningTokens };
+    return usage;
+}
+// deltas arriving between tool flush and the continuation request get buffered
+function emit(held, kind, t) {
+    if (held.sink)
+        (kind === "text" ? held.sink.text : held.sink.reasoning)(t);
+    else
+        held.buffer.push({ kind, t });
+}
+function openReply(held) {
+    if (held.opened)
+        return;
+    held.opened = true;
+    if (held.response)
+        held.reply.resolve(held.response);
+}
+function attachSink(held, sink) {
+    held.sink = sink;
+    if (held.buffer.length)
+        openReply(held);
+    for (const b of held.buffer)
+        (b.kind === "text" ? sink.text : sink.reasoning)(b.t);
+    held.buffer = [];
+}
+function attachSignal(held, signal) {
+    held.detachSignal?.();
+    held.detachSignal = null;
+    if (!signal)
+        return;
+    const onAbort = () => abortHeld(held);
+    signal.addEventListener("abort", onAbort, { once: true });
+    held.detachSignal = () => signal.removeEventListener("abort", onAbort);
+}
+function closeAgent(held) {
+    try {
+        held.agent.close();
+    }
+    catch { }
+}
+function teardownHeld(held) {
+    held.done = true;
+    if (held.slot) {
+        held.slot = false;
+        releaseSlot();
+    }
+    held.detachSignal?.();
+    held.detachSignal = null;
+    if (held.flushTimer)
+        clearTimeout(held.flushTimer);
+    if (held.idleTimer)
+        clearTimeout(held.idleTimer);
+    for (const id of held.parked.keys())
+        agentByToolCallId.delete(id);
+    heldByAgent.delete(held.agent.agentId);
+}
+function failHeld(held, err) {
+    teardownHeld(held);
+    if (statusFor(err) === 403)
+        markBlocked(held.model);
+    if (held.response && !held.opened) {
+        held.opened = true;
+        held.reply.resolve(errorResponse(err));
+        held.sink?.close();
+    }
+    else {
+        held.sink?.fail(err);
+    }
+    closeAgent(held);
+    releaseCwd(held.cwd);
+}
+function abortHeld(held) {
+    if (held.done)
+        return;
+    teardownHeld(held);
+    held.run?.cancel().catch(() => { });
+    closeAgent(held);
+    held.sink?.close();
+    held.reply.reject(new DOMException("aborted", "AbortError"));
+    releaseCwd(held.cwd);
+}
+/** Model requested tools: emit tool_calls, end this HTTP segment, park the run. */
+function flushToolCalls(held) {
+    held.flushTimer = null;
+    if (held.done || !held.pendingCalls.length)
+        return;
+    const calls = held.pendingCalls;
+    held.pendingCalls = [];
+    for (const c of calls)
+        agentByToolCallId.set(c.id, held.agent.agentId);
+    const sink = held.sink;
+    held.sink = null;
+    // the parked run outlives this HTTP segment, so its abort signal must not
+    // reach it; the continuation request attaches its own
+    held.detachSignal?.();
+    held.detachSignal = null;
+    openReply(held);
+    sink?.toolCalls(calls);
+    sink?.finish("tool_calls");
+    rememberSession(held, calls);
+    held.idleTimer = setTimeout(() => abortHeld(held), TOOL_RESULT_TIMEOUT_MS);
+    held.idleTimer.unref?.();
+}
+async function wireRunCompletion(held) {
+    if (held.wired || !held.run)
+        return;
+    held.wired = true;
+    let result;
+    try {
+        result = await held.run.wait();
+    }
+    catch (err) {
+        if (!held.done)
+            failHeld(held, err);
+        return;
+    }
+    if (held.done)
+        return;
+    if (result.status === "cancelled")
+        return abortHeld(held);
+    if (result.status === "error")
+        return failHeld(held, result.error ?? new Error("cursor run failed"));
+    const usage = mapUsage(result.usage) ?? held.usage;
+    teardownHeld(held);
+    rememberSession(held, []);
+    openReply(held);
+    held.sink?.finish("stop", usage);
+    closeAgent(held);
+}
+export function _resetForTest() {
+    sessions.clear();
+    diskSessions.clear();
+    heldByAgent.clear();
+    agentByToolCallId.clear();
+    sessionsLoaded = false;
+}
+export function _stats() {
+    return {
+        held: heldByAgent.size,
+        sessions: sessions.size,
+        disk: diskSessions.size,
+        agentIds: [...sessions.values()].map((v) => v.agentId).sort(),
+        active,
+        waiting: waiters.length,
+    };
+}
+export async function handleChatCompletion(body, apiKey, signal, scope) {
+    if (signal?.aborted)
+        throw new DOMException("aborted", "AbortError");
+    await loadSessions();
+    const streaming = body.stream !== false;
+    const reply = deferred();
+    let held;
+    const sse = streaming ? sseResponse(body.model, () => held && abortHeld(held)) : undefined;
+    const sink = sse?.sink ?? jsonCollector(body.model, reply.resolve);
+    // continuation: trailing tool results for a parked run
+    const lastMsg = body.messages[body.messages.length - 1];
+    if (lastMsg?.role === "tool" && lastMsg.tool_call_id) {
+        const agentId = agentByToolCallId.get(lastMsg.tool_call_id);
+        held = agentId ? heldByAgent.get(agentId) : undefined;
+        if (!held || held.done) {
+            return Response.json({ error: { message: "cursor run for this tool call expired — please retry", type: "invalid_request_error", code: "tool_call_expired" } }, { status: 400 });
+        }
+        if (held.idleTimer)
+            clearTimeout(held.idleTimer);
+        held.messages = body.messages;
+        held.textAcc = "";
+        held.reply = reply;
+        held.response = sse?.response ?? null;
+        held.opened = false;
+        attachSignal(held, signal);
+        attachSink(held, sink);
+        for (const m of body.messages) {
+            if (m.role !== "tool" || !m.tool_call_id)
+                continue;
+            const resolve = held.parked.get(m.tool_call_id);
+            if (resolve) {
+                held.parked.delete(m.tool_call_id);
+                agentByToolCallId.delete(m.tool_call_id);
+                resolve(textOf(m.content));
+            }
+        }
+        return reply.promise;
+    }
+    // new turn: reuse the agent whose last-seen conversation matches our prefix
+    const prefix = body.messages.slice(0, -1);
+    const key = hashMessages(prefix, scope);
+    await acquireSlot(signal);
+    const entry = sessions.get(key) ?? diskSessions.get(key);
+    let agent;
+    let cwd;
+    let newSuffix = body.messages;
+    const agentOptions = (cwd) => ({
+        model: resolveModel(body.model) ?? { id: body.model },
+        tools: ["mcp"],
+        ...(apiKey ? { apiKey } : {}),
+        local: { cwd, settingSources: ["project"], enableAgentRetries: true },
+    });
+    if (entry) {
+        sessions.delete(key);
+        diskSessions.delete(key);
+        cwd = entry.cwd;
+        agent = await withRetry(() => Agent.resume(entry.agentId, agentOptions(cwd)), signal).catch(() => {
+            saveSessions();
+            releaseCwd(entry.cwd);
+            return undefined;
+        });
+        if (agent)
+            newSuffix = body.messages.slice(-1);
+    }
+    if (!agent) {
+        cwd = await mkdtemp(TMP_CWD_PREFIX);
+        try {
+            agent = await withRetry(() => Agent.create(agentOptions(cwd)), signal);
+        }
+        catch (err) {
+            releaseSlot();
+            releaseCwd(cwd);
+            if (signal?.aborted)
+                throw abortError();
+            return errorResponse(err);
+        }
+    }
+    held = {
+        agent,
+        cwd: cwd,
+        model: body.model,
+        run: null,
+        messages: body.messages,
+        scope,
+        textAcc: "",
+        sink: null,
+        reply,
+        response: sse?.response ?? null,
+        opened: false,
+        detachSignal: null,
+        buffer: [],
+        pendingCalls: [],
+        parked: new Map(),
+        flushTimer: null,
+        idleTimer: null,
+        wired: false,
+        done: false,
+        slot: true,
+    };
+    const self = held;
+    heldByAgent.set(agent.agentId, held);
+    attachSignal(held, signal);
+    attachSink(held, sink);
+    const customTools = {};
+    for (const t of body.tools ?? []) {
+        customTools[t.function.name] = {
+            description: t.function.description ?? "",
+            inputSchema: t.function.parameters ?? { type: "object", properties: {} },
+            execute: (args, ctx) => {
+                const id = (ctx.toolCallId ?? `call_${randomUUID()}`).replace(/\s+/g, "_");
+                self.pendingCalls.push({ id, name: t.function.name, argumentsJson: JSON.stringify(args ?? {}) });
+                if (self.flushTimer)
+                    clearTimeout(self.flushTimer);
+                self.flushTimer = setTimeout(() => flushToolCalls(self), BATCH_SETTLE_MS);
+                return new Promise((resolve) => self.parked.set(id, resolve));
+            },
+        };
+    }
+    await syncAgentsMd(cwd, body.messages);
+    const prompt = newSuffix
+        .filter((m) => m.role !== "system")
+        .map((m) => (m.role === "user" ? textOf(m.content) : `${m.role.toUpperCase()}: ${textOf(m.content)}`))
+        .filter(Boolean)
+        .join("\n\n") || "(empty message)";
+    let run;
+    try {
+        run = await withRetry(() => agent.send(prompt, {
+            onDelta: ({ update }) => {
+                if (self.done)
+                    return;
+                if (update.type === "text-delta" && update.text) {
+                    openReply(self);
+                    self.textAcc += update.text;
+                    emit(self, "text", update.text);
+                }
+                else if (update.type === "thinking-delta" && update.text) {
+                    openReply(self);
+                    emit(self, "reasoning", update.text);
+                }
+                else if (update.type === "turn-ended") {
+                    self.usage = mapUsage(update.usage);
+                }
+            },
+            local: { customTools: customTools },
+        }), signal, 1000, (err) => !self.opened && !self.done && isTransient(err));
+    }
+    catch (err) {
+        if (!self.done)
+            failHeld(self, err);
+        return reply.promise;
+    }
+    if (self.done) {
+        run.cancel().catch(() => { });
+        return reply.promise;
+    }
+    if (run.agentId !== agent.agentId)
+        console.error(`[opencode-cursor-auth] run.agentId ${run.agentId} != agent.agentId ${agent.agentId}`);
+    self.run = run;
+    void wireRunCompletion(self);
+    return reply.promise;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin } from "@opencode-ai/plugin";
+import { type SdkAuthStatus } from "@cursor/sdk";
+export { parseContext } from "./models.js";
+export declare function keyProblem(status: SdkAuthStatus, nowMs: number): string | undefined;
+export declare const CursorAuthPlugin: Plugin;
+export default CursorAuthPlugin;

package/dist/index.js

@@ -0,0 +1,138 @@
+import { Cursor } from "@cursor/sdk";
+import { errorResponse, handleChatCompletion } from "./bridge.js";
+import { currentModels } from "./models.js";
+export { parseContext } from "./models.js";
+const BASE_URL = "http://cursor.local/v1";
+// Cursor publishes no output limit and the bridge never passes max_tokens to Cursor, so output is only an accounting reserve for opencode.
+const DEFAULT_CONTEXT = 200_000;
+const DEFAULT_OUTPUT = 32_000;
+export function keyProblem(status, nowMs) {
+    if (status.status !== "logged-in")
+        return "Cursor SDK key missing — run `opencode auth login` and pick Cursor";
+    if (typeof status.apiKeyExpiresAtMs === "number" && status.apiKeyExpiresAtMs <= nowMs)
+        return `Cursor SDK key expired on ${new Date(status.apiKeyExpiresAtMs).toISOString()} — run \`opencode auth login\` and pick Cursor`;
+    return undefined;
+}
+const KEY_CHECK_TTL_MS = 60_000;
+const EXPIRY_WARN_MS = 7 * 24 * 60 * 60 * 1000;
+let keyStatus;
+let warnedExpiry = false;
+async function checkKey() {
+    if (pastedApiKey || process.env.CURSOR_API_KEY)
+        return undefined;
+    const now = Date.now();
+    if (!keyStatus || now - keyStatus.at > KEY_CHECK_TTL_MS) {
+        keyStatus = { at: now, value: Cursor.auth.status().catch(() => undefined) };
+    }
+    const status = await keyStatus.value;
+    if (!status)
+        return undefined;
+    const exp = status.status === "logged-in" ? status.apiKeyExpiresAtMs : undefined;
+    if (!warnedExpiry && typeof exp === "number" && exp > now && exp - now <= EXPIRY_WARN_MS) {
+        warnedExpiry = true;
+        const days = Math.ceil((exp - now) / (24 * 60 * 60 * 1000));
+        console.error(`[opencode-cursor-auth] Cursor SDK key expires in ${days} days — run \`opencode auth login\` to renew`);
+    }
+    return keyProblem(status, now);
+}
+async function bodyText(input, init) {
+    const b = init?.body;
+    if (typeof b === "string")
+        return b;
+    if (b instanceof Uint8Array)
+        return new TextDecoder().decode(b);
+    if (input instanceof Request)
+        return input.text();
+    return "";
+}
+let pastedApiKey;
+async function cursorFetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    if (url.includes("/chat/completions")) {
+        const problem = await checkKey();
+        if (problem)
+            return errorResponse(problem, 401);
+        const body = JSON.parse(await bodyText(input, init));
+        const signal = init?.signal ?? (input instanceof Request ? input.signal : undefined);
+        const scope = new Headers(init?.headers).get("x-opencode-session") ??
+            (input instanceof Request ? input.headers.get("x-opencode-session") : null) ??
+            undefined;
+        return handleChatCompletion(body, pastedApiKey, signal, scope);
+    }
+    if (url.includes("/models")) {
+        return Response.json({
+            object: "list",
+            data: Object.keys(await currentModels()).map((id) => ({ id, object: "model" })),
+        });
+    }
+    return Response.json({ error: { message: `unsupported endpoint: ${url}` } }, { status: 404 });
+}
+export const CursorAuthPlugin = async () => {
+    return {
+        config: async (config) => {
+            const providers = (config.provider ??= {});
+            const cursor = (providers["cursor"] ??= { models: {} });
+            cursor.npm ??= "@ai-sdk/openai-compatible";
+            cursor.name ??= "Cursor";
+            cursor.options = { ...cursor.options, baseURL: BASE_URL };
+            cursor.models ??= {};
+            for (const [id, { name, context }] of Object.entries(await currentModels())) {
+                cursor.models[id] ??= { name };
+                const model = cursor.models[id];
+                model.cost = { input: 0, output: 0, cache_read: 0, cache_write: 0 };
+                model.limit ??= { context: context ?? DEFAULT_CONTEXT, output: DEFAULT_OUTPUT };
+            }
+        },
+        "chat.headers": async (input, output) => {
+            if (input.model.providerID === "cursor")
+                output.headers["x-opencode-session"] = input.sessionID;
+        },
+        auth: {
+            provider: "cursor",
+            loader: async (getAuth) => {
+                const auth = await getAuth().catch(() => undefined);
+                if (auth && auth.type === "api" && auth.key !== "cursor-sdk-store")
+                    pastedApiKey = auth.key;
+                return {
+                    apiKey: "cursor-managed",
+                    baseURL: BASE_URL,
+                    fetch: cursorFetch,
+                };
+            },
+            methods: [
+                {
+                    type: "oauth",
+                    label: "Log in with Cursor (browser)",
+                    authorize: async () => {
+                        let resolveUrl;
+                        const urlReady = new Promise((r) => (resolveUrl = r));
+                        const login = Cursor.auth
+                            .login({
+                            apiKeyName: "opencode-cursor-auth",
+                            openBrowser: false,
+                            onLoginUrl: (url) => resolveUrl(url),
+                        })
+                            .catch((err) => err);
+                        const url = await Promise.race([urlReady, login.then(() => "")]);
+                        return {
+                            url: typeof url === "string" && url ? url : "https://cursor.com/dashboard",
+                            instructions: "Complete the login in your browser. The key is stored in ~/.cursor/sdk/auth.json.",
+                            method: "auto",
+                            callback: async () => {
+                                const result = await login;
+                                if (result instanceof Error)
+                                    return { type: "failed" };
+                                return { type: "success", key: "cursor-sdk-store" };
+                            },
+                        };
+                    },
+                },
+                {
+                    type: "api",
+                    label: "Paste a Cursor API key (cursor.com/dashboard)",
+                },
+            ],
+        },
+    };
+};
+export default CursorAuthPlugin;

package/dist/models.d.ts

@@ -0,0 +1,13 @@
+import { type ModelListItem, type ModelParameterValue, type ModelSelection } from "@cursor/sdk";
+export type ModelInfo = {
+    name: string;
+    context?: number;
+    base?: string;
+    params?: ModelParameterValue[];
+    blocked?: true;
+};
+export declare function parseContext(m: ModelListItem): number | undefined;
+export declare function buildCatalog(list: ModelListItem[]): Record<string, ModelInfo>;
+export declare function currentModels(): Promise<Record<string, ModelInfo>>;
+export declare function resolveModel(opencodeId: string): ModelSelection | undefined;
+export declare function markBlocked(opencodeId: string): void;

package/dist/models.js

@@ -0,0 +1,115 @@
+import { Cursor } from "@cursor/sdk";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+const CACHE_DIR = join(homedir(), ".cache", "opencode-cursor-auth");
+const MODELS_CACHE_PATH = join(CACHE_DIR, "models.json");
+const MODELS_CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+let catalog = {};
+let fetchedAt = 0;
+function saveCatalog() {
+    mkdirSync(CACHE_DIR, { recursive: true });
+    writeFileSync(MODELS_CACHE_PATH, JSON.stringify({ version: 3, fetchedAt, models: catalog }));
+}
+function contextValue(raw) {
+    const match = raw?.trim().match(/^(\d+)([km]?)$/i);
+    if (!match)
+        return undefined;
+    const unit = match[2].toLowerCase();
+    return Number(match[1]) * (unit === "k" ? 1_000 : unit === "m" ? 1_000_000 : 1);
+}
+export function parseContext(m) {
+    return contextValue(m.parameters?.find((p) => p.id === "context")?.values[0]?.value);
+}
+export function buildCatalog(list) {
+    const models = {};
+    const rename = (id) => (id === "default" ? "auto" : id);
+    for (const m of list) {
+        const context = parseContext(m);
+        models[rename(m.id)] = { name: m.displayName ?? m.id, ...(context ? { context } : {}) };
+    }
+    for (const m of list) {
+        const base = rename(m.id);
+        for (const v of m.variants ?? []) {
+            // id = base + non-default param values (first listed value is the default); "true" flags use the param id, e.g. gpt-5.5-low-fast
+            const parts = v.params
+                .filter((p) => m.parameters?.find((d) => d.id === p.id)?.values[0]?.value !== p.value)
+                .map((p) => (p.value === "true" ? p.id : p.value));
+            const id = [base, ...parts].join("-");
+            if (models[id])
+                continue;
+            const context = contextValue(v.params.find((p) => p.id === "context")?.value) ?? models[base].context;
+            const label = v.displayName && v.displayName !== m.displayName ? v.displayName : parts.join(" ");
+            models[id] = { name: `${models[base].name} (${label})`, ...(context ? { context } : {}), base, params: v.params };
+        }
+    }
+    return models;
+}
+function loadCachedModels() {
+    try {
+        const raw = JSON.parse(readFileSync(MODELS_CACHE_PATH, "utf8"));
+        if (raw?.version === 3 && raw.models && Object.keys(raw.models).length > 0)
+            return raw;
+    }
+    catch {
+        // no cache yet, or unreadable — fall back
+    }
+    return undefined;
+}
+// Live model list from Cursor, cached 24h to keep opencode startup fast.
+// Offline/logged-out: stale cache if present, else just "auto" (Cursor's universal alias).
+// Models Cursor has rejected with "Model Blocked" for this account are hidden
+// until the cache file is deleted (the catalog itself carries no entitlement info).
+export async function currentModels() {
+    const cached = loadCachedModels();
+    if (cached && Date.now() - cached.fetchedAt <= MODELS_CACHE_TTL_MS) {
+        catalog = cached.models;
+        fetchedAt = cached.fetchedAt;
+    }
+    else {
+        try {
+            catalog = buildCatalog(await Cursor.models.list());
+            for (const [id, m] of Object.entries(cached?.models ?? {}))
+                if (m.blocked && catalog[id])
+                    catalog[id].blocked = true;
+            fetchedAt = Date.now();
+            saveCatalog();
+        }
+        catch {
+            catalog = cached?.models ?? { auto: { name: "Auto" } };
+            fetchedAt = cached?.fetchedAt ?? 0;
+        }
+    }
+    return Object.fromEntries(Object.entries(catalog).filter(([, m]) => !m.blocked));
+}
+function loadCatalog() {
+    if (Object.keys(catalog).length)
+        return;
+    const cached = loadCachedModels();
+    catalog = cached?.models ?? {};
+    fetchedAt = cached?.fetchedAt ?? 0;
+}
+export function resolveModel(opencodeId) {
+    loadCatalog();
+    const m = catalog[opencodeId];
+    if (!m)
+        return undefined;
+    return m.base && m.params ? { id: m.base, params: m.params } : { id: opencodeId };
+}
+export function markBlocked(opencodeId) {
+    loadCatalog();
+    const base = catalog[opencodeId]?.base ?? opencodeId;
+    let changed = false;
+    for (const [id, m] of Object.entries(catalog)) {
+        if ((id === base || m.base === base) && !m.blocked)
+            m.blocked = changed = true;
+    }
+    if (changed) {
+        try {
+            saveCatalog();
+        }
+        catch {
+            // cache dir unwritable — the in-memory flag still hides it for this process
+        }
+    }
+}

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@vidit19sharma/opencode-cursor-auth",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "OpenCode plugin that uses your Cursor subscription via the official @cursor/sdk \u2014 no proxy server, no separate login.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "author": "Vidit Sharma <vidit19sharma@gmail.com> (https://github.com/vidit19sharma)",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vidit19sharma/opencode-cursor-auth.git"
+  },
+  "bugs": {
+    "url": "https://github.com/vidit19sharma/opencode-cursor-auth/issues"
+  },
+  "homepage": "https://github.com/vidit19sharma/opencode-cursor-auth#readme",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "cursor",
+    "cursor-sdk",
+    "ai",
+    "llm",
+    "auth"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "bun spike/e2e-bridge.ts",
+    "spike": "bun spike/validate-sdk.ts",
+    "prepublishOnly": "tsc"
+  },
+  "dependencies": {
+    "@cursor/sdk": "^1.0.36"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "*"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "latest",
+    "@types/node": "^26.6.5",
+    "typescript": "^5.7.0"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "license": "MIT"
+}