opencode-cursor-provider 0.1.0 → 0.2.0

package/README.md

@@ -107,6 +107,19 @@ bun run build
 
 The source code is in `src/`. The build writes the package files to `dist/`.
 
+## Release
+
+Releases use [Release Please](https://github.com/googleapis/release-please) with conventional commits (`feat:`, `fix:`, `docs:`, …). Merging to `main` opens or updates a release PR. Merging that PR tags a GitHub release and publishes to npm.
+
+Configure an npm trusted publisher with these values:
+
+- Organization or user: `pragmaticivan`
+- Repository: `opencode-cursor-provider`
+- Workflow filename: `release-please.yml`
+- Allowed action: `npm publish`
+
+The workflow uses OpenID Connect and does not need an npm token.
+
 ## License
 
 Apache License 2.0. See [`LICENSE`](LICENSE).

package/dist/catalog/source.d.ts

@@ -1,8 +1,15 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import type { CursorLink } from "../auth/link.ts";
+import type { CursorApiKey } from "../ids.ts";
 import { type CursorModelDescriptor } from "./catalog.ts";
+export interface ModelSourceDependencies {
+    restoreCredential(): Promise<void>;
+    resolveApiKey(): Promise<CursorApiKey | undefined>;
+    rejectCredential(): void;
+    reloadCatalog(): Promise<void>;
+    listModels?(apiKey: CursorApiKey): Promise<unknown>;
+}
 export interface ModelSource {
     list(): readonly CursorModelDescriptor[];
-    refresh(ctx: Plugin.Context): Promise<void>;
+    refresh(): Promise<void>;
+    close(): Promise<void>;
 }
-export declare function createModelSource(link: CursorLink): ModelSource;
+export declare function createModelSource(dependencies: ModelSourceDependencies): ModelSource;

package/dist/catalog/source.js

@@ -1,30 +1,83 @@
 import { AuthenticationError, Cursor } from "@cursor/sdk";
 import { parseListedModels, SEED_MODELS } from "./catalog.js";
-export function createModelSource(link) {
-    let models = [...SEED_MODELS];
-    return {
-        list() {
-            return models;
-        },
-        async refresh(ctx) {
-            await link.restore(ctx);
-            const apiKey = await link.resolve();
-            if (apiKey === undefined)
-                return;
-            try {
-                models = parseListedModels(await Cursor.models.list({ apiKey }));
-            }
-            catch (error) {
-                if (error instanceof AuthenticationError)
-                    link.reject();
-                return;
+export function createModelSource(dependencies) {
+    const listModels = dependencies.listModels ?? ((apiKey) => Cursor.models.list({ apiKey }));
+    let snapshot = { kind: "seed", models: SEED_MODELS };
+    let catalogDirty = false;
+    let activeDrain;
+    let trailingRefresh = false;
+    let closed = false;
+    let closing;
+    async function reloadDirtyCatalog() {
+        if (!catalogDirty)
+            return;
+        try {
+            await dependencies.reloadCatalog();
+            catalogDirty = false;
+        }
+        catch {
+            return;
+        }
+    }
+    function selectSeeds() {
+        if (snapshot.kind === "seed")
+            return;
+        snapshot = { kind: "seed", models: SEED_MODELS };
+        catalogDirty = true;
+    }
+    async function refreshOnce() {
+        await dependencies.restoreCredential();
+        const apiKey = await dependencies.resolveApiKey();
+        if (apiKey === undefined) {
+            selectSeeds();
+            await reloadDirtyCatalog();
+            return;
+        }
+        try {
+            snapshot = { kind: "listed", models: parseListedModels(await listModels(apiKey)) };
+            catalogDirty = true;
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError) {
+                dependencies.rejectCredential();
+                selectSeeds();
             }
+        }
+        await reloadDirtyCatalog();
+    }
+    function startDrain() {
+        return (async () => {
             try {
-                await ctx.catalog.reload();
+                do {
+                    trailingRefresh = false;
+                    await refreshOnce();
+                } while (trailingRefresh);
             }
-            catch {
-                // Keep the listed models. The next credential or poll can replay the catalog.
+            finally {
+                activeDrain = undefined;
             }
+        })();
+    }
+    return {
+        list() {
+            return snapshot.models;
+        },
+        refresh() {
+            if (closed)
+                return Promise.resolve();
+            if (activeDrain !== undefined) {
+                trailingRefresh = true;
+                return activeDrain;
+            }
+            activeDrain = startDrain();
+            return activeDrain;
+        },
+        close() {
+            if (closing !== undefined)
+                return closing;
+            closed = true;
+            closing = activeDrain ?? Promise.resolve();
+            return closing;
         },
     };
 }

package/dist/plugin.d.ts

@@ -1,2 +1,11 @@
 import { Plugin } from "@opencode-ai/plugin";
 export declare const plugin: Plugin.Plugin;
+export interface ModelWatcherDependencies {
+    onLinked(listener: () => void): () => void;
+    subscribe(signal: AbortSignal): AsyncIterable<{
+        readonly type: string;
+    }>;
+    refresh(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare function watchModels(dependencies: ModelWatcherDependencies): () => Promise<void>;

package/dist/plugin.js

@@ -13,7 +13,12 @@ export const plugin = Plugin.define({
     id: "opencode-cursor-provider",
     async setup(ctx) {
         const link = createCursorLink();
-        const models = createModelSource(link);
+        const models = createModelSource({
+            restoreCredential: () => link.restore(ctx),
+            resolveApiKey: () => link.resolve(),
+            rejectCredential: () => link.reject(),
+            reloadCatalog: () => ctx.catalog.reload(),
+        });
         const bridge = createSessionAgentBridge({
             link,
             models: () => models.list(),
@@ -54,9 +59,14 @@ export const plugin = Plugin.define({
                 event.language = languageModel(event.model, event.model.id, event.options);
             }, { providerID: PROVIDER_ID }),
         ];
-        const stopRefresh = watchModels(ctx, link, models);
+        const stopRefresh = watchModels({
+            onLinked: (listener) => link.onLinked(listener),
+            subscribe: (signal) => ctx.event.subscribe({ signal }),
+            refresh: () => models.refresh(),
+            close: () => models.close(),
+        });
         return async () => {
-            stopRefresh();
+            await stopRefresh();
             for (const registration of registrations.toReversed()) {
                 await registration.dispose();
             }
@@ -94,16 +104,20 @@ function writeSystem(system, stamped) {
             system[index] = { type: "text", text };
     }
 }
-function watchModels(ctx, link, models) {
+export function watchModels(dependencies) {
     const events = new AbortController();
+    let stopped = false;
+    let cleanup;
     const refresh = () => {
-        void models.refresh(ctx);
+        if (stopped)
+            return;
+        void dependencies.refresh().catch(() => { });
     };
-    const stopLinked = link.onLinked(refresh);
+    const stopLinked = dependencies.onLinked(refresh);
     refresh();
-    void (async () => {
+    const eventTask = (async () => {
         try {
-            for await (const event of ctx.event.subscribe({ signal: events.signal })) {
+            for await (const event of dependencies.subscribe(events.signal)) {
                 if (event.type === "credential.updated" || event.type === "credential.switched")
                     refresh();
             }
@@ -119,9 +133,17 @@ function watchModels(ctx, link, models) {
     }, REFRESH_FOR_MS);
     stop.unref?.();
     return () => {
-        stopLinked();
-        events.abort();
-        clearInterval(retry);
-        clearTimeout(stop);
+        if (cleanup !== undefined)
+            return cleanup;
+        cleanup = (async () => {
+            stopped = true;
+            stopLinked();
+            events.abort();
+            clearInterval(retry);
+            clearTimeout(stop);
+            await eventTask;
+            await dependencies.close();
+        })();
+        return cleanup;
     };
 }

package/package.json

@@ -1,22 +1,38 @@
 {
   "name": "opencode-cursor-provider",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenCode 2 plugin that connects Cursor via the official SDK",
   "type": "module",
   "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pragmaticivan/opencode-cursor-provider.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pragmaticivan/opencode-cursor-provider/issues"
+  },
+  "homepage": "https://github.com/pragmaticivan/opencode-cursor-provider#readme",
   "engines": {
     "node": ">=22.13"
   },
-  "main": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./src/index.ts",
-    "./server": "./src/index.ts"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
   },
   "files": [
     "dist"
   ],
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "bun test"
   },