opencode-cursor-provider 0.1.0

package/dist/plugin.js

@@ -0,0 +1,127 @@
+import { Plugin } from "@opencode-ai/plugin";
+import { createCursorLink } from "./auth/link.js";
+import { createSessionAgentBridge } from "./bridge/bridge.js";
+import { sessionFromId } from "./bridge/correlation.js";
+import { applyModels, applyProvider, modelParamsFromOptions } from "./catalog/catalog.js";
+import { createModelSource } from "./catalog/source.js";
+import { asCatalogModelID, PROVIDER_ID } from "./ids.js";
+import { toLanguageModel } from "./model/language-model.js";
+import { bindRuntime } from "./runtime.js";
+const REFRESH_EVERY_MS = 5_000;
+const REFRESH_FOR_MS = 300_000;
+export const plugin = Plugin.define({
+    id: "opencode-cursor-provider",
+    async setup(ctx) {
+        const link = createCursorLink();
+        const models = createModelSource(link);
+        const bridge = createSessionAgentBridge({
+            link,
+            models: () => models.list(),
+        });
+        bindRuntime({
+            bridge,
+            models: () => models.list(),
+        });
+        const languageModel = (model, fallbackID, options) => toLanguageModel({
+            bridge,
+            modelID: asCatalogModelID(model.id),
+            wireID: model.modelID || fallbackID,
+            ...paramsOption(options),
+        });
+        const registrations = [
+            await ctx.integration.transform((draft) => {
+                link.register(draft);
+            }),
+            await ctx.catalog.transform((draft) => {
+                applyProvider(draft);
+                applyModels(draft, models.list());
+            }),
+            await ctx.session.hook("context", async (event) => {
+                event.tools = {};
+                if (String(event.agent) === "compaction" || String(event.agent) === "title")
+                    return;
+                const stamped = bridge.annotate(event.system.map((part) => part.text), sessionFromId(event.sessionID, await sessionCwd(ctx, event.sessionID)));
+                writeSystem(event.system, stamped);
+            }, { providerID: PROVIDER_ID }),
+            await ctx.aisdk.hook("sdk", (event) => {
+                if (event.sdk)
+                    return;
+                event.sdk = {
+                    languageModel: (modelID) => languageModel(event.model, modelID, event.options),
+                };
+            }, { providerID: PROVIDER_ID }),
+            await ctx.aisdk.hook("language", (event) => {
+                event.language = languageModel(event.model, event.model.id, event.options);
+            }, { providerID: PROVIDER_ID }),
+        ];
+        const stopRefresh = watchModels(ctx, link, models);
+        return async () => {
+            stopRefresh();
+            for (const registration of registrations.toReversed()) {
+                await registration.dispose();
+            }
+        };
+    },
+});
+function paramsOption(options) {
+    const params = modelParamsFromOptions(options);
+    if (params === undefined)
+        return {};
+    return { params };
+}
+async function sessionCwd(ctx, sessionID) {
+    try {
+        const info = await ctx.session.get({ sessionID });
+        if (info.location.directory.length > 0)
+            return info.location.directory;
+    }
+    catch {
+        // Session lookup is best-effort. Plugin location is the fallback cwd.
+    }
+    return ctx.location.directory;
+}
+function writeSystem(system, stamped) {
+    for (let index = 0; index < stamped.length; index += 1) {
+        const text = stamped[index];
+        if (text === undefined)
+            continue;
+        const existing = system[index];
+        if (existing === undefined) {
+            system.push({ type: "text", text });
+            continue;
+        }
+        if (existing.text !== text)
+            system[index] = { type: "text", text };
+    }
+}
+function watchModels(ctx, link, models) {
+    const events = new AbortController();
+    const refresh = () => {
+        void models.refresh(ctx);
+    };
+    const stopLinked = link.onLinked(refresh);
+    refresh();
+    void (async () => {
+        try {
+            for await (const event of ctx.event.subscribe({ signal: events.signal })) {
+                if (event.type === "credential.updated" || event.type === "credential.switched")
+                    refresh();
+            }
+        }
+        catch {
+            // Subscription ends when the plugin unloads.
+        }
+    })();
+    const retry = setInterval(refresh, REFRESH_EVERY_MS);
+    retry.unref?.();
+    const stop = setTimeout(() => {
+        clearInterval(retry);
+    }, REFRESH_FOR_MS);
+    stop.unref?.();
+    return () => {
+        stopLinked();
+        events.abort();
+        clearInterval(retry);
+        clearTimeout(stop);
+    };
+}

package/dist/runtime.d.ts

@@ -0,0 +1,8 @@
+import type { SessionAgentBridge } from "./bridge/bridge.ts";
+import { type CursorModelDescriptor } from "./catalog/catalog.ts";
+export interface CursorRuntime {
+    readonly bridge: SessionAgentBridge;
+    readonly models: () => readonly CursorModelDescriptor[];
+}
+export declare function bindRuntime(next: CursorRuntime): void;
+export declare function model(modelID: string, settings?: unknown): import("@ai-sdk/provider").LanguageModelV3;

package/dist/runtime.js

@@ -0,0 +1,25 @@
+import { modelParamsFromOptions, resolveWireId } from "./catalog/catalog.js";
+import { asCatalogModelID, asCursorModelID } from "./ids.js";
+import { toLanguageModel } from "./model/language-model.js";
+let runtime;
+export function bindRuntime(next) {
+    runtime = next;
+}
+export function model(modelID, settings) {
+    if (runtime === undefined) {
+        throw new Error("Cursor is not loaded. Add opencode-cursor-provider to plugins and restart OpenCode.");
+    }
+    const wireID = resolveWireId(runtime.models(), modelID) ?? asCursorModelID(modelID);
+    return toLanguageModel({
+        bridge: runtime.bridge,
+        modelID: asCatalogModelID(modelID),
+        wireID,
+        ...paramsOption(settings),
+    });
+}
+function paramsOption(settings) {
+    const params = modelParamsFromOptions(settings);
+    if (params === undefined)
+        return {};
+    return { params };
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "opencode-cursor-provider",
+  "version": "0.1.0",
+  "description": "OpenCode 2 plugin that connects Cursor via the official SDK",
+  "type": "module",
+  "license": "Apache-2.0",
+  "engines": {
+    "node": ">=22.13"
+  },
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts",
+    "./server": "./src/index.ts"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "bun test"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "3.0.8",
+    "@cursor/sdk": "^1.0.31",
+    "@opencode-ai/plugin": "beta"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.0",
+    "@types/node": "^22.20.1",
+    "typescript": "^5.9.3"
+  }
+}