opencode-ext-connector 0.3.0

package/dist/opencode/provider-entry.d.ts

@@ -0,0 +1,25 @@
+import type { AuthHook } from "@opencode-ai/plugin";
+import type { ProviderAdapter } from "../core/adapter";
+import type { Clock } from "../core/clock";
+import type { HttpTransport } from "../core/http";
+import type { CredentialRefreshPolicy } from "../core/options";
+import type { OpenCodeAuthStore } from "./auth-store";
+import type { IntegrationEnvMethod } from "./beta-api";
+export type ProviderEntryDeps = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly transport: HttpTransport;
+    readonly clock: Clock;
+    readonly authStore: OpenCodeAuthStore;
+    readonly writeBackCredentials: boolean;
+    readonly credentialRefresh?: CredentialRefreshPolicy;
+};
+export type ProviderEntry = {
+    readonly id: string;
+    readonly displayName: string;
+    readonly integrationId: string;
+    readonly integrationMethod: IntegrationEnvMethod;
+    readonly fallbackModelIds?: readonly string[];
+    readonly createAdapter: (deps: ProviderEntryDeps) => ProviderAdapter;
+    readonly createAuthHook: (deps: ProviderEntryDeps) => AuthHook;
+    readonly isConnected: (deps: ProviderEntryDeps) => Promise<boolean>;
+};

package/dist/opencode/provider-entry.js

@@ -0,0 +1 @@
+export {};

package/dist/opencode/providers.d.ts

@@ -0,0 +1,16 @@
+import type { ClaudeCredentials } from "../providers/claude/credentials";
+import type { OllamaCatalogState } from "../providers/ollama/catalog-state";
+import { type OllamaFetch } from "../providers/ollama/http";
+import type { ProviderEntry } from "./provider-entry";
+export type ProviderConnectionActive = (integrationId: string) => Promise<boolean>;
+export type ClaudeCredentialWriter = (env: Readonly<Record<string, string | undefined>>, credentials: ClaudeCredentials) => Promise<void>;
+export type ProviderRegistryOptions = {
+    readonly writeClaudeCredentials?: ClaudeCredentialWriter;
+    readonly ollama?: {
+        readonly fetch: OllamaFetch;
+        readonly catalog: OllamaCatalogState;
+    };
+};
+export declare function selectConfiguredProviders(entries: readonly ProviderEntry[], providerIds: readonly string[]): readonly ProviderEntry[];
+export declare function selectActiveProviders(entries: readonly ProviderEntry[], isActive: ProviderConnectionActive): Promise<readonly ProviderEntry[]>;
+export declare function createProviderRegistry(options?: ProviderRegistryOptions): readonly ProviderEntry[];

package/dist/opencode/providers.js

@@ -0,0 +1,140 @@
+import { createClaudeAdapter } from "../providers/claude/adapter";
+import { createClaudeTokenManager, readClaudeCredentials } from "../providers/claude/auth";
+import { createClaudeVersionResolver } from "../providers/claude/cli-version";
+import { listClaudeModels } from "../providers/claude/models";
+import { createCommandCodeAdapter } from "../providers/command-code/adapter";
+import { readCommandCodeAccessToken } from "../providers/command-code/auth";
+import { listCommandCodeModels } from "../providers/command-code/models";
+import { createCursorAdapter } from "../providers/cursor/adapter";
+import { readCursorAccessToken } from "../providers/cursor/auth";
+import { listCursorUsableModels } from "../providers/cursor/models";
+import { createOllamaAdapter } from "../providers/ollama/adapter";
+import { productionOllamaFetch } from "../providers/ollama/http";
+import { probeLocalOllama } from "./ollama-probe";
+import { productionOllamaCatalog } from "./ollama-production";
+import { createAnthropicCliAuth } from "./v1-anthropic-auth";
+import { createCommandCodeSessionAuth, createCursorSessionAuth, createOllamaSessionAuth, } from "./v1-session-auth";
+async function readCommandCodeToken(deps, signal) {
+    const match = await deps.authStore.matchAuth("command-code");
+    if (match === null) {
+        return null;
+    }
+    switch (match.kind) {
+        case "api-key":
+            return match.key;
+        case "marker":
+            return readCommandCodeAccessToken(deps.env, signal);
+        case "oauth":
+            return null;
+    }
+}
+export function selectConfiguredProviders(entries, providerIds) {
+    const selected = new Set(providerIds);
+    return entries.filter((entry) => selected.has(entry.id));
+}
+export async function selectActiveProviders(entries, isActive) {
+    const selected = [];
+    for (const entry of entries) {
+        if (await isActive(entry.integrationId)) {
+            selected.push(entry);
+        }
+    }
+    return selected;
+}
+export function createProviderRegistry(options = {}) {
+    const writeClaudeCredentials = options.writeClaudeCredentials;
+    const ollama = options.ollama ?? {
+        fetch: productionOllamaFetch,
+        catalog: productionOllamaCatalog,
+    };
+    return [
+        {
+            id: "claude",
+            displayName: "Claude",
+            integrationId: "anthropic",
+            integrationMethod: { type: "env", names: ["CLAUDE_EXT_CONNECTOR_ENABLED"] },
+            createAdapter: (deps) => {
+                const readVersion = createClaudeVersionResolver(deps);
+                return createClaudeAdapter({
+                    readAccessToken: async (signal) => {
+                        const credentials = await readClaudeCredentials(deps.env, signal);
+                        return credentials?.accessToken ?? null;
+                    },
+                    listModels: async (token, signal) => {
+                        const version = await readVersion(signal);
+                        return version === null
+                            ? []
+                            : listClaudeModels({ transport: deps.transport, token, signal, version });
+                    },
+                });
+            },
+            createAuthHook: (deps) => {
+                const tokenManager = createClaudeTokenManager({
+                    env: deps.env,
+                    clock: deps.clock,
+                    transport: deps.transport,
+                    ...(deps.credentialRefresh === undefined ? {} : { refresh: deps.credentialRefresh }),
+                    ...(deps.writeBackCredentials && writeClaudeCredentials !== undefined
+                        ? {
+                            writeBack: (credentials) => writeClaudeCredentials(deps.env, credentials),
+                        }
+                        : {}),
+                });
+                return createAnthropicCliAuth({
+                    provider: "anthropic",
+                    readCredentials: (signal) => readClaudeCredentials(deps.env, signal),
+                    readAccessToken: tokenManager.readAccessToken,
+                    forceRefreshAccessToken: tokenManager.forceRefreshAccessToken,
+                    readVersion: createClaudeVersionResolver(deps),
+                });
+            },
+            isConnected: async (deps) => {
+                if ((await deps.authStore.matchAuth("anthropic")) === null) {
+                    return false;
+                }
+                const signal = new AbortController().signal;
+                return (await readClaudeCredentials(deps.env, signal)) !== null;
+            },
+        },
+        {
+            id: "cursor",
+            displayName: "Cursor",
+            integrationId: "cursor",
+            integrationMethod: { type: "env", names: ["CURSOR_EXT_CONNECTOR_ENABLED"] },
+            fallbackModelIds: ["default"],
+            createAdapter: (deps) => createCursorAdapter({
+                readAccessToken: (signal) => readCursorAccessToken(deps.env, signal),
+                listModels: (token, signal) => listCursorUsableModels(token, signal),
+            }),
+            createAuthHook: (deps) => createCursorSessionAuth(deps.env),
+            isConnected: async (deps) => (await deps.authStore.matchAuth("cursor")) !== null &&
+                (await readCursorAccessToken(deps.env, new AbortController().signal)) !== null,
+        },
+        {
+            id: "command-code",
+            displayName: "Command Code",
+            integrationId: "command-code",
+            integrationMethod: { type: "env", names: ["COMMAND_CODE_API_KEY"] },
+            fallbackModelIds: ["Qwen/Qwen3.8-Max"],
+            createAdapter: (deps) => createCommandCodeAdapter({
+                readAccessToken: (signal) => readCommandCodeToken(deps, signal),
+                listModels: (token, signal) => listCommandCodeModels(deps.transport, token, signal),
+            }),
+            createAuthHook: (deps) => createCommandCodeSessionAuth(deps.env),
+            isConnected: async (deps) => (await readCommandCodeToken(deps, new AbortController().signal)) !== null,
+        },
+        {
+            id: "ollama",
+            displayName: "Ollama",
+            integrationId: "ollama",
+            integrationMethod: { type: "env", names: ["OLLAMA_EXT_CONNECTOR_ENABLED"] },
+            createAdapter: () => createOllamaAdapter(ollama),
+            createAuthHook: () => createOllamaSessionAuth(ollama.fetch),
+            isConnected: async (deps) => {
+                if ((await deps.authStore.matchAuth("ollama")) === null)
+                    return false;
+                return probeLocalOllama(ollama.fetch);
+            },
+        },
+    ];
+}

package/dist/opencode/register-integrations.d.ts

@@ -0,0 +1,3 @@
+import type { IntegrationDraft } from "./beta-api";
+import type { ProviderEntry } from "./provider-entry";
+export declare function registerProviderIntegrations(entries: readonly ProviderEntry[], draft: IntegrationDraft): void;

package/dist/opencode/register-integrations.js

@@ -0,0 +1,8 @@
+export function registerProviderIntegrations(entries, draft) {
+    for (const entry of entries) {
+        draft.method.update({
+            integrationID: entry.integrationId,
+            method: entry.integrationMethod,
+        });
+    }
+}

package/dist/opencode/reload.d.ts

@@ -0,0 +1,9 @@
+import type { Clock } from "../core/clock";
+export type CatalogReloadOptions = {
+    readonly clock: Clock;
+    readonly intervalMs: number;
+    readonly reload: () => Promise<void>;
+};
+export declare function scheduleCatalogReload(options: CatalogReloadOptions): {
+    readonly dispose: () => Promise<void>;
+};

package/dist/opencode/reload.js

@@ -0,0 +1,30 @@
+import { createAsyncDisposable } from "../core/lifecycle";
+export function scheduleCatalogReload(options) {
+    if (options.intervalMs <= 0) {
+        return createAsyncDisposable(() => undefined);
+    }
+    let cancelled = false;
+    let scheduled;
+    let activeReload;
+    const arm = () => {
+        scheduled = options.clock.schedule(options.intervalMs, () => {
+            if (cancelled) {
+                return;
+            }
+            scheduled = undefined;
+            activeReload = options.reload().then(() => undefined, () => undefined);
+            void activeReload.then(() => {
+                activeReload = undefined;
+                if (!cancelled) {
+                    arm();
+                }
+            });
+        });
+    };
+    arm();
+    return createAsyncDisposable(async () => {
+        cancelled = true;
+        scheduled?.cancel();
+        await activeReload;
+    });
+}

package/dist/opencode/v1-anthropic-auth.d.ts

@@ -0,0 +1,9 @@
+import type { AuthHook } from "@opencode-ai/plugin";
+import type { ClaudeCredentials } from "../providers/claude/credentials";
+export declare function createAnthropicCliAuth(options: {
+    readonly readCredentials: (signal: AbortSignal) => Promise<ClaudeCredentials | null>;
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly forceRefreshAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly readVersion: (signal: AbortSignal) => Promise<string | null>;
+    readonly provider?: string;
+}): AuthHook;

package/dist/opencode/v1-anthropic-auth.js

@@ -0,0 +1,55 @@
+import { createClaudeCompatibilityFetch } from "../providers/claude/compat-request";
+export function createAnthropicCliAuth(options) {
+    const provider = options.provider ?? "anthropic";
+    return {
+        provider,
+        loader: async (getAuth) => {
+            const auth = await getAuth();
+            if (!("type" in auth) || auth.type !== "oauth") {
+                return {};
+            }
+            const credentials = await options.readCredentials(new AbortController().signal);
+            if (credentials === null) {
+                return {};
+            }
+            return {
+                apiKey: "",
+                baseURL: "https://api.anthropic.com/v1",
+                fetch: createClaudeCompatibilityFetch({
+                    readVersion: options.readVersion,
+                    readAccessToken: options.readAccessToken,
+                    forceRefreshAccessToken: options.forceRefreshAccessToken,
+                }),
+            };
+        },
+        methods: [
+            {
+                type: "oauth",
+                label: "Claude Code subscription",
+                authorize: async () => {
+                    const credentials = await options.readCredentials(new AbortController().signal);
+                    if (credentials === null) {
+                        return {
+                            url: "",
+                            instructions: "No Claude Code credentials were found. Log in with Claude Code once or copy an existing `~/.claude/.credentials.json` here, then retry.",
+                            method: "auto",
+                            callback: async () => ({ type: "failed" }),
+                        };
+                    }
+                    return {
+                        url: "",
+                        instructions: "Using existing Claude Code credentials.",
+                        method: "auto",
+                        callback: async () => ({
+                            type: "success",
+                            provider,
+                            access: credentials.accessToken,
+                            refresh: credentials.refreshToken ?? "",
+                            expires: credentials.expiresAtMs ?? 0,
+                        }),
+                    };
+                },
+            },
+        ],
+    };
+}

package/dist/opencode/v1-catalog.d.ts

@@ -0,0 +1,13 @@
+import type { Hooks } from "@opencode-ai/plugin";
+import type { CatalogPublisher } from "../core/adapter";
+import type { ProviderEntry } from "./provider-entry";
+type HostConfig = Parameters<NonNullable<Hooks["config"]>>[0];
+export type V1CatalogProjector = {
+    readonly publisher: CatalogPublisher;
+    readonly attach: (config: HostConfig) => void;
+};
+export declare function createV1CatalogProjector(options: {
+    readonly entries: readonly ProviderEntry[];
+    readonly npmSpecifiers?: Readonly<Record<string, string>>;
+}): V1CatalogProjector;
+export {};

package/dist/opencode/v1-catalog.js

@@ -0,0 +1,80 @@
+import { InvalidArgumentError, OperationCancelledError } from "../core/errors";
+function assertNever(_value) {
+    throw new InvalidArgumentError("snapshot.status");
+}
+function modelRecord(snapshot, entry) {
+    const models = {};
+    const ids = snapshot.status === "unavailable" ? [] : snapshot.models.map((model) => model.id);
+    const selected = ids.length === 0 ? (entry.fallbackModelIds ?? []) : ids;
+    for (const id of selected) {
+        Object.defineProperty(models, id, {
+            value: { id, name: id },
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+    }
+    return models;
+}
+export function createV1CatalogProjector(options) {
+    const entries = new Map(options.entries.map((entry) => [entry.id, entry]));
+    const modelsByProvider = new Map();
+    const ownedProviders = new Set();
+    let attachedConfig;
+    const project = (entry) => {
+        if (attachedConfig === undefined || options.npmSpecifiers === undefined)
+            return;
+        const npm = options.npmSpecifiers[entry.id];
+        if (npm === undefined)
+            return;
+        const models = modelsByProvider.get(entry.id);
+        if (models === undefined) {
+            if (ownedProviders.delete(entry.id) && attachedConfig.provider !== undefined) {
+                Reflect.deleteProperty(attachedConfig.provider, entry.id);
+            }
+            return;
+        }
+        const provider = attachedConfig.provider ?? {};
+        Object.defineProperty(provider, entry.id, {
+            value: { npm, name: entry.displayName, models },
+            enumerable: true,
+            configurable: true,
+            writable: true,
+        });
+        attachedConfig.provider = provider;
+        ownedProviders.add(entry.id);
+    };
+    return {
+        publisher: {
+            publish: async (snapshot, signal) => {
+                if (signal.aborted)
+                    throw new OperationCancelledError("publish-v1-catalog");
+                const entry = entries.get(snapshot.providerId);
+                if (entry === undefined)
+                    throw new InvalidArgumentError("snapshot.providerId");
+                switch (snapshot.status) {
+                    case "unavailable":
+                        modelsByProvider.delete(entry.id);
+                        break;
+                    case "ready":
+                    case "stale": {
+                        const models = modelRecord(snapshot, entry);
+                        if (Reflect.ownKeys(models).length === 0)
+                            modelsByProvider.delete(entry.id);
+                        else
+                            modelsByProvider.set(entry.id, models);
+                        break;
+                    }
+                    default:
+                        assertNever(snapshot);
+                }
+                project(entry);
+            },
+        },
+        attach: (config) => {
+            attachedConfig = config;
+            for (const entry of options.entries)
+                project(entry);
+        },
+    };
+}

package/dist/opencode/v1-language.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+export declare function languageForV1Provider(providerID: string, modelId: string, options: Readonly<Record<string, unknown>>): LanguageModelV3;
+export declare const disposeV1LanguageRuntime: () => Promise<void>;

package/dist/opencode/v1-language.js

@@ -0,0 +1,64 @@
+import { createFetchHttpTransport } from "../http/fetch-transport";
+import { createConsoleLogger } from "../logging/logger";
+import { createClaudeTokenReader } from "../providers/claude/auth";
+import { readCursorAccessToken } from "../providers/cursor/auth";
+import { createCursorDirectRuntime } from "../providers/cursor/direct-runtime";
+import { createConnectorLanguage } from "./language-factory";
+import { productionOllamaRuntime } from "./ollama-production";
+const clock = {
+    nowMs: () => Date.now(),
+    schedule: (delayMs, callback) => {
+        const handle = setTimeout(callback, delayMs);
+        handle.unref();
+        const cancel = () => {
+            clearTimeout(handle);
+        };
+        return {
+            cancel,
+            [Symbol.dispose]: cancel,
+        };
+    },
+};
+const env = process.env;
+const transport = createFetchHttpTransport();
+const logger = createConsoleLogger(clock);
+const cursorRuntime = createCursorDirectRuntime({
+    clock,
+    readAccessToken: (signal) => readCursorAccessToken(env, signal),
+    onBackgroundCleanupError: (error) => {
+        logger.log("warn", "cursor.session.ttl-cleanup-failed", {
+            code: error.code,
+            operation: error.operation,
+            sessionId: error.identity.sessionId,
+            modelId: error.identity.modelId,
+        });
+    },
+});
+const readClaudeToken = createClaudeTokenReader({
+    env,
+    clock,
+    transport,
+});
+function apiKeyFromOptions(options) {
+    const value = options["apiKey"];
+    return typeof value === "string" && value.length > 0 && !value.startsWith("cli-session:")
+        ? value
+        : undefined;
+}
+export function languageForV1Provider(providerID, modelId, options) {
+    const commandCodeApiKey = apiKeyFromOptions(options);
+    const createLanguage = createConnectorLanguage({
+        env,
+        transport,
+        readClaudeToken,
+        cursorRuntime,
+        ollamaRuntime: productionOllamaRuntime,
+        ...(commandCodeApiKey === undefined ? {} : { commandCodeApiKey }),
+    });
+    const model = createLanguage(providerID, modelId);
+    if (model === null) {
+        throw new Error(`${providerID} is unavailable`);
+    }
+    return model;
+}
+export const disposeV1LanguageRuntime = cursorRuntime.dispose;

package/dist/opencode/v1-module.d.ts

@@ -0,0 +1,23 @@
+import type { Hooks, Plugin as V1Plugin } from "@opencode-ai/plugin";
+import type { Clock } from "../core/clock";
+import type { HealthPolicy } from "../core/health";
+import type { HttpTransport } from "../core/http";
+import type { ConnectorLogger } from "../core/logger";
+import type { OpenCodeAuthStore } from "./auth-store";
+import type { ProviderEntry, ProviderEntryDeps } from "./provider-entry";
+export type V1ServerOptions = {
+    readonly clock: Clock;
+    readonly transport: HttpTransport;
+    readonly authStore: OpenCodeAuthStore;
+    readonly env?: Readonly<Record<string, string | undefined>>;
+    readonly providers: readonly ProviderEntry[];
+    readonly snapshotTimeoutMs?: number;
+    readonly catalogReloadMs?: number;
+    readonly health?: HealthPolicy;
+    readonly logger?: ConnectorLogger;
+    readonly npmSpecifiers?: Readonly<Record<string, string>>;
+};
+export declare function buildV1Hooks(options: V1ServerOptions): Promise<Hooks>;
+export declare function buildV1AuthHooks(entry: ProviderEntry, deps: ProviderEntryDeps, options: unknown): Hooks;
+export declare function createV1AuthServer(entry: ProviderEntry, deps: ProviderEntryDeps): V1Plugin;
+export declare function createV1Server(options: V1ServerOptions): V1Plugin;

package/dist/opencode/v1-module.js

@@ -0,0 +1,74 @@
+import { createAsyncDisposable } from "../core/lifecycle";
+import { parseConnectorOptions } from "../core/options";
+import { refreshAdaptersWithHealth } from "./health-refresh";
+import { pickConnectorOptionsInput } from "./host-options";
+import { scheduleCatalogReload } from "./reload";
+import { createV1CatalogProjector } from "./v1-catalog";
+function entryDeps(options) {
+    return {
+        env: options.env ?? process.env,
+        transport: options.transport,
+        clock: options.clock,
+        authStore: options.authStore,
+        writeBackCredentials: false,
+    };
+}
+export async function buildV1Hooks(options) {
+    const deps = entryDeps(options);
+    const providers = [];
+    for (const entry of options.providers) {
+        if (await entry.isConnected(deps)) {
+            providers.push(entry);
+        }
+    }
+    const adapters = providers.map((entry) => entry.createAdapter(deps));
+    const projector = createV1CatalogProjector({
+        entries: providers,
+        ...(options.npmSpecifiers === undefined ? {} : { npmSpecifiers: options.npmSpecifiers }),
+    });
+    const lifetime = new AbortController();
+    const healthStore = new Map();
+    const refresh = () => refreshAdaptersWithHealth({
+        adapters,
+        publisher: projector.publisher,
+        logger: options.logger ?? { log: () => undefined },
+        clock: options.clock,
+        health: options.health ?? { initialBackoffMs: 1_000, maximumBackoffMs: 60_000 },
+        store: healthStore,
+        signal: lifetime.signal,
+        snapshotTimeoutMs: options.snapshotTimeoutMs ?? 30_000,
+    });
+    await refresh();
+    const reload = scheduleCatalogReload({
+        clock: options.clock,
+        intervalMs: options.catalogReloadMs ?? 300_000,
+        reload: refresh,
+    });
+    const disposal = createAsyncDisposable(async () => {
+        lifetime.abort();
+        await reload.dispose();
+        await Promise.all(adapters.map((adapter) => adapter.dispose()));
+    });
+    return {
+        config: async (config) => projector.attach(config),
+        dispose: disposal.dispose,
+    };
+}
+export function buildV1AuthHooks(entry, deps, options) {
+    const configured = parseConnectorOptions(pickConnectorOptionsInput(options));
+    return configured.providers.some((providerId) => providerId === entry.id)
+        ? {
+            auth: entry.createAuthHook({
+                ...deps,
+                writeBackCredentials: configured.writeBackCredentials,
+                credentialRefresh: configured.credentialRefresh,
+            }),
+        }
+        : {};
+}
+export function createV1AuthServer(entry, deps) {
+    return async (_input, options) => buildV1AuthHooks(entry, deps, options);
+}
+export function createV1Server(options) {
+    return async () => buildV1Hooks(options);
+}

package/dist/opencode/v1-session-auth.d.ts

@@ -0,0 +1,5 @@
+import type { AuthHook } from "@opencode-ai/plugin";
+import { type OllamaFetch } from "../providers/ollama/http";
+export declare function createCursorSessionAuth(env: Readonly<Record<string, string | undefined>>): AuthHook;
+export declare function createCommandCodeSessionAuth(env: Readonly<Record<string, string | undefined>>): AuthHook;
+export declare function createOllamaSessionAuth(fetch?: OllamaFetch): AuthHook;