opencode-ext-connector 0.3.0

package/dist/http/package-version.js

@@ -0,0 +1,46 @@
+const REGISTRY_URL = "https://registry.npmjs.org";
+const SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
+function versionFromPayload(body) {
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder().decode(body));
+    }
+    catch {
+        return null;
+    }
+    if (typeof parsed !== "object" || parsed === null || !("version" in parsed)) {
+        return null;
+    }
+    const version = Reflect.get(parsed, "version");
+    return typeof version === "string" && SEMVER_PATTERN.test(version) ? version : null;
+}
+export function createPackageVersionResolver(options) {
+    const url = `${REGISTRY_URL}/${encodeURIComponent(options.packageName)}/latest`;
+    let resolved = null;
+    let inFlight = null;
+    const lookup = async (signal) => {
+        try {
+            const response = await options.transport.request({ method: "GET", url, headers: { accept: "application/json" }, body: null }, signal);
+            if (response.status < 200 || response.status >= 300) {
+                return null;
+            }
+            return versionFromPayload(response.body);
+        }
+        catch {
+            return null;
+        }
+    };
+    return async (signal) => {
+        if (resolved !== null) {
+            return resolved;
+        }
+        if (inFlight === null) {
+            inFlight = lookup(signal).then((version) => {
+                resolved = version;
+                inFlight = null;
+                return version;
+            });
+        }
+        return inFlight;
+    };
+}

package/dist/http/read-body.d.ts

@@ -0,0 +1,9 @@
+import type { HttpHeaders, HttpRequest, HttpTransport } from "../core/http";
+export type HttpBodyStream = {
+    readonly status: number;
+    readonly statusText?: string;
+    readonly headers: HttpHeaders;
+    readonly chunks: AsyncIterable<Uint8Array>;
+    readonly bodyPresent: boolean;
+};
+export declare function openHttpBody(transport: HttpTransport, request: HttpRequest, signal: AbortSignal): Promise<HttpBodyStream>;

package/dist/http/read-body.js

@@ -0,0 +1,22 @@
+export async function openHttpBody(transport, request, signal) {
+    if (transport.stream !== undefined) {
+        const streamed = await transport.stream(request, signal);
+        return {
+            status: streamed.status,
+            ...(streamed.statusText === undefined ? {} : { statusText: streamed.statusText }),
+            headers: streamed.headers,
+            chunks: streamed.body,
+            bodyPresent: streamed.bodyPresent ?? true,
+        };
+    }
+    const response = await transport.request(request, signal);
+    return {
+        status: response.status,
+        ...(response.statusText === undefined ? {} : { statusText: response.statusText }),
+        headers: response.headers,
+        chunks: (async function* () {
+            yield response.body;
+        })(),
+        bodyPresent: response.bodyPresent ?? true,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import type { Plugin as V1Plugin } from "@opencode-ai/plugin";
+export declare const connectorServer: V1Plugin;
+export declare const claudeAuthServer: V1Plugin;
+export declare const cursorAuthServer: V1Plugin;
+export declare const commandCodeAuthServer: V1Plugin;
+export declare const ollamaAuthServer: V1Plugin;

package/dist/index.js

@@ -0,0 +1,5 @@
+export const connectorServer = async (input, options) => (await import("./server.js")).connectorServer(input, options);
+export const claudeAuthServer = async (input, options) => (await import("./server.js")).claudeAuthServer(input, options);
+export const cursorAuthServer = async (input, options) => (await import("./server.js")).cursorAuthServer(input, options);
+export const commandCodeAuthServer = async (input, options) => (await import("./server.js")).commandCodeAuthServer(input, options);
+export const ollamaAuthServer = async (input, options) => (await import("./server.js")).ollamaAuthServer(input, options);

package/dist/logging/logger.d.ts

@@ -0,0 +1,4 @@
+import type { Clock } from "../core/clock";
+import { type ConnectorLogger, type LogSink } from "../core/logger";
+export declare function createConsoleLogSink(): LogSink;
+export declare function createConsoleLogger(clock: Clock): ConnectorLogger;

package/dist/logging/logger.js

@@ -0,0 +1,11 @@
+import { createConnectorLogger, } from "../core/logger";
+export function createConsoleLogSink() {
+    return {
+        write(record) {
+            console.info(JSON.stringify(record));
+        },
+    };
+}
+export function createConsoleLogger(clock) {
+    return createConnectorLogger(clock, createConsoleLogSink());
+}

package/dist/opencode/auth-store.d.ts

@@ -0,0 +1,19 @@
+export type OpenCodeAuthProvider = "anthropic" | "cursor" | "command-code" | "ollama";
+export type OpenCodeAuthMatch = {
+    readonly kind: "oauth";
+} | {
+    readonly kind: "marker";
+} | {
+    readonly kind: "api-key";
+    readonly key: string;
+};
+export type OpenCodeAuthStore = {
+    readonly matchAuth: (provider: OpenCodeAuthProvider) => Promise<OpenCodeAuthMatch | null>;
+};
+export type OpenCodeAuthStoreOptions = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly platform?: string;
+    readonly readFile?: (path: string) => Promise<string>;
+};
+export declare function opencodeAuthJsonPaths(env: Readonly<Record<string, string | undefined>>, platform?: string): readonly string[];
+export declare function createOpenCodeAuthStore(options: OpenCodeAuthStoreOptions): OpenCodeAuthStore;

package/dist/opencode/auth-store.js

@@ -0,0 +1,107 @@
+import { readFile as readAuthFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { z } from "zod";
+const authRootSchema = z.record(z.string(), z.unknown());
+const oauthRecordSchema = z
+    .object({
+    type: z.literal("oauth"),
+    access: z.string().min(1),
+    refresh: z.string().min(1),
+    expires: z.number().finite(),
+    accountId: z.string().optional(),
+    enterpriseUrl: z.string().optional(),
+})
+    .strict();
+const apiRecordSchema = z
+    .object({
+    type: z.literal("api"),
+    key: z.string().min(1),
+    metadata: z.record(z.string(), z.string()).optional(),
+})
+    .strict();
+export function opencodeAuthJsonPaths(env, platform = process.platform) {
+    const home = env["HOME"] ?? homedir();
+    const dataHome = env["XDG_DATA_HOME"];
+    if (dataHome !== undefined && dataHome.length > 0) {
+        return [join(dataHome, "opencode", "auth.json")];
+    }
+    const paths = [];
+    if (platform === "darwin") {
+        paths.push(join(home, "Library", "Application Support", "opencode", "auth.json"));
+    }
+    else if (platform === "win32") {
+        paths.push(join(env["LOCALAPPDATA"] ?? join(home, "AppData", "Local"), "opencode", "auth.json"));
+    }
+    else {
+        paths.push(join(home, ".local", "share", "opencode", "auth.json"));
+    }
+    return [...new Set(paths)];
+}
+function isMissingFile(error) {
+    return error instanceof Error && "code" in error && Reflect.get(error, "code") === "ENOENT";
+}
+function parseAuthMatch(provider, value) {
+    switch (provider) {
+        case "anthropic":
+            return oauthRecordSchema.safeParse(value).success ? { kind: "oauth" } : null;
+        case "cursor": {
+            const parsed = apiRecordSchema.safeParse(value);
+            return parsed.success && parsed.data.key === "cli-session:cursor" ? { kind: "marker" } : null;
+        }
+        case "ollama": {
+            const parsed = apiRecordSchema.safeParse(value);
+            return parsed.success && parsed.data.key === "cli-session:ollama" ? { kind: "marker" } : null;
+        }
+        case "command-code": {
+            const parsed = apiRecordSchema.safeParse(value);
+            if (!parsed.success) {
+                return null;
+            }
+            if (parsed.data.key === "cli-session:command-code") {
+                return { kind: "marker" };
+            }
+            return parsed.data.key.startsWith("cli-session:")
+                ? null
+                : { kind: "api-key", key: parsed.data.key };
+        }
+    }
+}
+export function createOpenCodeAuthStore(options) {
+    const readFile = options.readFile ?? ((path) => readAuthFile(path, "utf8"));
+    const paths = opencodeAuthJsonPaths(options.env, options.platform);
+    return {
+        matchAuth: async (provider) => {
+            for (const path of paths) {
+                let raw;
+                try {
+                    raw = await readFile(path);
+                }
+                catch (error) {
+                    if (isMissingFile(error)) {
+                        continue;
+                    }
+                    throw error;
+                }
+                let parsedJson;
+                try {
+                    parsedJson = JSON.parse(raw);
+                }
+                catch (error) {
+                    if (error instanceof SyntaxError) {
+                        continue;
+                    }
+                    throw error;
+                }
+                const root = authRootSchema.safeParse(parsedJson);
+                if (root.success) {
+                    const match = parseAuthMatch(provider, root.data[provider]);
+                    if (match !== null) {
+                        return match;
+                    }
+                }
+            }
+            return null;
+        },
+    };
+}

package/dist/opencode/beta-api.d.ts

@@ -0,0 +1,3 @@
+export type { AISDKHooks, CatalogDraft, CatalogHooks, CatalogProviderRecord, IntegrationDraft, Plugin, PluginContext, Registration, } from "@opencode-ai/plugin/v2/promise";
+export { define } from "@opencode-ai/plugin/v2/promise";
+export type { IntegrationEnvMethod, ModelV2Info, ProviderV2Info } from "@opencode-ai/sdk/v2/types";

package/dist/opencode/beta-api.js

@@ -0,0 +1 @@
+export { define } from "@opencode-ai/plugin/v2/promise";

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

@@ -0,0 +1,3 @@
+import type { CatalogPublisher } from "../core/adapter";
+import type { CatalogDraft } from "./beta-api";
+export declare function createCatalogPublisher(draft: CatalogDraft): CatalogPublisher;

package/dist/opencode/catalog-bridge.js

@@ -0,0 +1,85 @@
+import { InvalidArgumentError, OperationCancelledError } from "../core/errors";
+function assertNever(_value) {
+    throw new InvalidArgumentError("snapshot.status");
+}
+function defaultProviderApi() {
+    return {
+        type: "aisdk",
+        package: "opencode-ext-connector",
+    };
+}
+function defaultModelFields(modelId) {
+    return {
+        api: {
+            id: modelId,
+            type: "aisdk",
+            package: "opencode-ext-connector",
+        },
+        capabilities: {
+            tools: true,
+            input: ["text"],
+            output: ["text"],
+        },
+        request: {
+            headers: {},
+            body: {},
+        },
+        variants: [],
+        time: {
+            released: 0,
+        },
+        cost: [],
+        status: "active",
+        enabled: true,
+        limit: {
+            context: 0,
+            output: 0,
+        },
+    };
+}
+export function createCatalogPublisher(draft) {
+    return {
+        publish: async (snapshot, signal) => {
+            if (signal.aborted) {
+                throw new OperationCancelledError("publish-catalog");
+            }
+            const providerId = snapshot.providerId;
+            switch (snapshot.status) {
+                case "unavailable":
+                    draft.provider.remove(providerId);
+                    return;
+                case "ready":
+                case "stale": {
+                    draft.provider.update(providerId, (provider) => {
+                        provider.id = providerId;
+                        provider.name = providerId;
+                        provider.disabled = false;
+                        provider.api = defaultProviderApi();
+                        provider.request = { headers: {}, body: {} };
+                    });
+                    const nextIds = new Set(snapshot.models.map((model) => model.id));
+                    const existing = draft.provider.get(providerId);
+                    if (existing !== undefined) {
+                        for (const modelId of existing.models.keys()) {
+                            if (!nextIds.has(modelId)) {
+                                draft.model.remove(providerId, modelId);
+                            }
+                        }
+                    }
+                    for (const model of snapshot.models) {
+                        draft.model.update(providerId, model.id, (info) => {
+                            info.id = model.id;
+                            info.providerID = providerId;
+                            info.name = model.id;
+                            info.enabled = true;
+                            Object.assign(info, defaultModelFields(model.id));
+                        });
+                    }
+                    return;
+                }
+                default:
+                    assertNever(snapshot);
+            }
+        },
+    };
+}

package/dist/opencode/health-refresh.d.ts

@@ -0,0 +1,16 @@
+import type { CatalogPublisher, ProviderAdapter } from "../core/adapter";
+import type { Clock } from "../core/clock";
+import { type HealthPolicy, type HealthState } from "../core/health";
+import type { ProviderId } from "../core/ids";
+import type { ConnectorLogger } from "../core/logger";
+export type HealthStore = Map<ProviderId, HealthState>;
+export declare function refreshAdaptersWithHealth(options: {
+    readonly adapters: readonly ProviderAdapter[];
+    readonly publisher: CatalogPublisher;
+    readonly logger: ConnectorLogger;
+    readonly clock: Clock;
+    readonly health: HealthPolicy;
+    readonly store: HealthStore;
+    readonly signal: AbortSignal;
+    readonly snapshotTimeoutMs?: number;
+}): Promise<void>;

package/dist/opencode/health-refresh.js

@@ -0,0 +1,49 @@
+import { refreshProviderCatalog } from "../core/adapter";
+import { createDeadline } from "../core/deadline";
+import { ConnectorError } from "../core/errors";
+import { createInitialHealthState, reduceHealth, } from "../core/health";
+function errorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return "unknown";
+}
+export async function refreshAdaptersWithHealth(options) {
+    const nowMs = options.clock.nowMs();
+    for (const adapter of options.adapters) {
+        const current = options.store.get(adapter.providerId) ?? createInitialHealthState();
+        if (current.retryAtMs !== null && nowMs < current.retryAtMs) {
+            options.logger.log("debug", "provider.snapshot.deferred", {
+                providerId: adapter.providerId,
+                retryAtMs: current.retryAtMs,
+            });
+            continue;
+        }
+        const deadline = createDeadline({
+            clock: options.clock,
+            timeoutMs: options.snapshotTimeoutMs ?? 30_000,
+            parentSignal: options.signal,
+        });
+        try {
+            const snapshot = await refreshProviderCatalog({
+                adapter,
+                publisher: options.publisher,
+                signal: deadline.signal,
+            });
+            const status = snapshot.status === "ready" ? "ready" : snapshot.status;
+            options.store.set(adapter.providerId, reduceHealth(current, { status, atMs: nowMs }, options.health));
+        }
+        catch (error) {
+            options.store.set(adapter.providerId, reduceHealth(current, { status: "unavailable", atMs: nowMs }, options.health));
+            const retryable = error instanceof ConnectorError ? error.retryable : false;
+            options.logger.log("warn", "provider.snapshot.failed", {
+                providerId: adapter.providerId,
+                retryable,
+                message: errorMessage(error),
+            });
+        }
+        finally {
+            await deadline.dispose();
+        }
+    }
+}

package/dist/opencode/host-options.d.ts

@@ -0,0 +1,2 @@
+import type { ConnectorOptionsInput } from "../core/options";
+export declare function pickConnectorOptionsInput(input: unknown): ConnectorOptionsInput;

package/dist/opencode/host-options.js

@@ -0,0 +1,49 @@
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function nonNegativeInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
+function pickCredentialRefresh(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const rawMode = "mode" in value ? value.mode : undefined;
+    const mode = rawMode === "auto" || rawMode === "never" ? rawMode : undefined;
+    const leadMs = "leadMs" in value ? nonNegativeInteger(value.leadMs) : undefined;
+    if (mode === undefined && leadMs === undefined) {
+        return undefined;
+    }
+    return { mode, leadMs };
+}
+function pickHealth(value) {
+    if (typeof value !== "object" || value === null) {
+        return undefined;
+    }
+    const initialBackoffMs = "initialBackoffMs" in value ? positiveInteger(value.initialBackoffMs) : undefined;
+    const maximumBackoffMs = "maximumBackoffMs" in value ? positiveInteger(value.maximumBackoffMs) : undefined;
+    if (initialBackoffMs === undefined && maximumBackoffMs === undefined) {
+        return undefined;
+    }
+    return { initialBackoffMs, maximumBackoffMs };
+}
+export function pickConnectorOptionsInput(input) {
+    if (typeof input !== "object" || input === null) {
+        return {};
+    }
+    return {
+        providers: "providers" in input && Array.isArray(input.providers)
+            ? input.providers.filter((provider) => provider === "claude" ||
+                provider === "cursor" ||
+                provider === "command-code" ||
+                provider === "ollama")
+            : undefined,
+        snapshotTimeoutMs: "snapshotTimeoutMs" in input ? positiveInteger(input.snapshotTimeoutMs) : undefined,
+        writeBackCredentials: "writeBackCredentials" in input && typeof input.writeBackCredentials === "boolean"
+            ? input.writeBackCredentials
+            : undefined,
+        credentialRefresh: "credentialRefresh" in input ? pickCredentialRefresh(input.credentialRefresh) : undefined,
+        catalogReloadMs: "catalogReloadMs" in input ? nonNegativeInteger(input.catalogReloadMs) : undefined,
+        health: "health" in input ? pickHealth(input.health) : undefined,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { HttpTransport } from "../core/http";
+import type { CursorDirectRuntime } from "../providers/cursor/direct-runtime";
+import type { OllamaRuntime } from "../providers/ollama/runtime";
+export type ConnectorLanguageDeps = {
+    readonly env: Readonly<Record<string, string | undefined>>;
+    readonly transport: HttpTransport;
+    readonly readClaudeToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly cursorRuntime: CursorDirectRuntime;
+    readonly ollamaRuntime: OllamaRuntime;
+    readonly commandCodeApiKey?: string;
+};
+export declare function createConnectorLanguage(deps: ConnectorLanguageDeps): (providerID: string, modelId: string) => LanguageModelV3 | null;

package/dist/opencode/language-factory.js

@@ -0,0 +1,37 @@
+import { createClaudeLanguageModel } from "../providers/claude/language-model";
+import { readCommandCodeAccessToken } from "../providers/command-code/auth";
+import { createCommandCodeLanguageModel } from "../providers/command-code/language-model";
+import { createCursorLanguageModel } from "../providers/cursor/language-model";
+import { createOllamaLanguageModel } from "../providers/ollama/language-model";
+export function createConnectorLanguage(deps) {
+    return (providerID, modelId) => {
+        if (providerID === "claude") {
+            return createClaudeLanguageModel({
+                modelId,
+                transport: deps.transport,
+                readAccessToken: deps.readClaudeToken,
+            });
+        }
+        if (providerID === "cursor") {
+            return createCursorLanguageModel({
+                modelId,
+                runPrompt: async () => null,
+                directRuntime: deps.cursorRuntime,
+            });
+        }
+        if (providerID === "command-code") {
+            return createCommandCodeLanguageModel({
+                modelId,
+                transport: deps.transport,
+                env: deps.env,
+                readAccessToken: (signal) => deps.commandCodeApiKey === undefined
+                    ? readCommandCodeAccessToken(deps.env, signal)
+                    : Promise.resolve(deps.commandCodeApiKey),
+            });
+        }
+        if (providerID === "ollama") {
+            return createOllamaLanguageModel({ modelId, runtime: deps.ollamaRuntime });
+        }
+        return null;
+    };
+}

package/dist/opencode/ollama-probe.d.ts

@@ -0,0 +1,2 @@
+import type { OllamaFetch } from "../providers/ollama/http";
+export declare function probeLocalOllama(fetch: OllamaFetch): Promise<boolean>;

package/dist/opencode/ollama-probe.js

@@ -0,0 +1,15 @@
+import { OperationCancelledError } from "../core/errors";
+import { OllamaCatalogError } from "../providers/ollama/errors";
+import { listLocalOllamaModels } from "../providers/ollama/local-catalog";
+const OLLAMA_PROBE_TIMEOUT_MS = 5_000;
+export async function probeLocalOllama(fetch) {
+    try {
+        await listLocalOllamaModels(fetch, AbortSignal.timeout(OLLAMA_PROBE_TIMEOUT_MS));
+        return true;
+    }
+    catch (error) {
+        if (error instanceof OllamaCatalogError || error instanceof OperationCancelledError)
+            return false;
+        throw error;
+    }
+}

package/dist/opencode/ollama-production.d.ts

@@ -0,0 +1,4 @@
+import { type OllamaCatalogState } from "../providers/ollama/catalog-state";
+import { type OllamaRuntime } from "../providers/ollama/runtime";
+export declare const productionOllamaCatalog: OllamaCatalogState;
+export declare const productionOllamaRuntime: OllamaRuntime;

package/dist/opencode/ollama-production.js

@@ -0,0 +1,10 @@
+import { createOllamaCatalogState, } from "../providers/ollama/catalog-state";
+import { productionOllamaFetch } from "../providers/ollama/http";
+import { createOllamaRuntime } from "../providers/ollama/runtime";
+export const productionOllamaCatalog = createOllamaCatalogState({
+    fetch: productionOllamaFetch,
+});
+export const productionOllamaRuntime = createOllamaRuntime({
+    catalog: productionOllamaCatalog,
+    fetch: productionOllamaFetch,
+});

package/dist/opencode/plugin.d.ts

@@ -0,0 +1,33 @@
+import type { LanguageModelV3 } from "@ai-sdk/provider";
+import type { CatalogPublisher, ProviderAdapter } from "../core/adapter";
+import type { Clock } from "../core/clock";
+import type { HealthPolicy } from "../core/health";
+import type { ConnectorLogger } from "../core/logger";
+import type { CatalogDraft, Registration } from "./beta-api";
+import { type HealthStore } from "./health-refresh";
+export declare const PLUGIN_ID: string;
+export type CatalogHost = {
+    readonly transform: (callback: (draft: CatalogDraft) => Promise<void> | void) => Promise<Registration>;
+};
+export type LanguageHost = {
+    readonly language: (callback: (input: {
+        readonly model: {
+            readonly providerID: string;
+            readonly id: string;
+        };
+        language?: LanguageModelV3;
+    }) => void) => Promise<Registration>;
+};
+export type ConnectorSetupOptions = {
+    readonly catalog: CatalogHost;
+    readonly adapters: readonly ProviderAdapter[];
+    readonly logger: ConnectorLogger;
+    readonly createPublisher: (draft: CatalogDraft) => CatalogPublisher;
+    readonly clock?: Clock;
+    readonly health?: HealthPolicy;
+    readonly healthStore?: HealthStore;
+    readonly aisdk?: LanguageHost;
+    readonly createLanguage?: (providerID: string, modelId: string) => LanguageModelV3 | null;
+    readonly snapshotTimeoutMs?: number;
+};
+export declare function setupConnector(options: ConnectorSetupOptions): Promise<Registration>;

package/dist/opencode/plugin.js

@@ -0,0 +1,40 @@
+import { refreshAdaptersWithHealth } from "./health-refresh";
+export const PLUGIN_ID = "opencode-ext-connector";
+export async function setupConnector(options) {
+    const catalogRegistration = await options.catalog.transform(async (draft) => {
+        const publisher = options.createPublisher(draft);
+        await refreshAdaptersWithHealth({
+            adapters: options.adapters,
+            publisher,
+            logger: options.logger,
+            clock: options.clock ?? {
+                nowMs: () => 0,
+                schedule: () => ({
+                    cancel: () => undefined,
+                    [Symbol.dispose]: () => undefined,
+                }),
+            },
+            health: options.health ?? { initialBackoffMs: 1_000, maximumBackoffMs: 60_000 },
+            store: options.healthStore ?? new Map(),
+            signal: new AbortController().signal,
+            snapshotTimeoutMs: options.snapshotTimeoutMs ?? 30_000,
+        });
+    });
+    if (options.aisdk !== undefined && options.createLanguage !== undefined) {
+        const createLanguage = options.createLanguage;
+        await options.aisdk.language((input) => {
+            const language = createLanguage(input.model.providerID, input.model.id);
+            if (language !== null) {
+                input.language = language;
+            }
+        });
+    }
+    return {
+        dispose: async () => {
+            await catalogRegistration.dispose();
+            for (const adapter of options.adapters) {
+                await adapter.dispose();
+            }
+        },
+    };
+}

package/dist/opencode/process-exit.d.ts

@@ -0,0 +1,4 @@
+export declare function bindProcessExit(dispose: () => Promise<void>, emitter?: {
+    readonly once: (event: string, listener: () => void) => void;
+    readonly off?: (event: string, listener: () => void) => void;
+}): () => void;

package/dist/opencode/process-exit.js

@@ -0,0 +1,22 @@
+export function bindProcessExit(dispose, emitter = process) {
+    let ran = false;
+    const listener = () => {
+        if (ran) {
+            return;
+        }
+        ran = true;
+        void dispose();
+    };
+    const events = ["beforeExit", "SIGINT", "SIGTERM"];
+    for (const event of events) {
+        emitter.once(event, listener);
+    }
+    return () => {
+        ran = true;
+        if (emitter.off !== undefined) {
+            for (const event of events) {
+                emitter.off(event, listener);
+            }
+        }
+    };
+}