opencode-ext-connector 0.3.0

package/dist/providers/command-code/request-lifecycle.js

@@ -0,0 +1,33 @@
+import { OperationCancelledError } from "../../core/errors";
+import { commandCodeResponseBodyTooLargeError } from "./errors";
+export { commandCodeHttpError } from "./errors";
+const MAX_ERROR_BODY_BYTES = 64 * 1024;
+export function createCommandCodeRequestLifecycle(parent, timeoutMs) {
+    const controller = new AbortController();
+    const abort = () => {
+        if (!controller.signal.aborted) {
+            controller.abort(new OperationCancelledError("command-code-stream"));
+        }
+    };
+    parent?.addEventListener("abort", abort, { once: true });
+    const handle = setTimeout(abort, timeoutMs);
+    handle.unref();
+    const dispose = () => {
+        clearTimeout(handle);
+        parent?.removeEventListener("abort", abort);
+    };
+    return { signal: controller.signal, abort, dispose };
+}
+export async function readCommandCodeErrorBody(chunks) {
+    const decoder = new TextDecoder();
+    let result = "";
+    let byteLength = 0;
+    for await (const chunk of chunks) {
+        byteLength += chunk.byteLength;
+        if (byteLength > MAX_ERROR_BODY_BYTES) {
+            throw commandCodeResponseBodyTooLargeError();
+        }
+        result += decoder.decode(chunk, { stream: true });
+    }
+    return result + decoder.decode();
+}

package/dist/providers/command-code/request.d.ts

@@ -0,0 +1,14 @@
+import type { LanguageModelV3CallOptions } from "@ai-sdk/provider";
+import type { CommandCodeSessionId } from "./session";
+export type BuildHeadersOptions = {
+    readonly token: string;
+    readonly cliVersion: string;
+    readonly sessionId: CommandCodeSessionId;
+};
+export type BuildBodyOptions = {
+    readonly modelId: string;
+    readonly call: LanguageModelV3CallOptions;
+    readonly sessionId: CommandCodeSessionId;
+};
+export declare function buildHeaders(options: BuildHeadersOptions): Record<string, string>;
+export declare function buildBody(options: BuildBodyOptions): Record<string, unknown>;

package/dist/providers/command-code/request.js

@@ -0,0 +1,167 @@
+// Derived from brent-weatherall/opencode-commandcode-provider src/convert.ts.
+// Licensed under MIT. See THIRD_PARTY_NOTICES.md.
+import { randomBytes } from "node:crypto";
+export function buildHeaders(options) {
+    const { token, cliVersion, sessionId } = options;
+    return {
+        accept: "application/json, */*",
+        "accept-encoding": "gzip, deflate, br",
+        "accept-language": "en-US,en;q=0.9",
+        authorization: `Bearer ${token}`,
+        connection: "keep-alive",
+        "content-type": "application/json",
+        traceparent: `00-${randomBytes(16).toString("hex")}-${randomBytes(8).toString("hex")}-01`,
+        "user-agent": `commandcode-cli/${cliVersion} Node.js/${process.version}`,
+        "x-cli-environment": "production",
+        "x-co-flag": "false",
+        "x-command-code-version": cliVersion,
+        "x-project-slug": "opencode",
+        "x-session-id": sessionId,
+        "x-taste-learning": "false",
+    };
+}
+function imageData(data, mediaType) {
+    if (data instanceof URL) {
+        return data.toString();
+    }
+    const encoded = typeof data === "string" ? data : Buffer.from(data).toString("base64");
+    return `data:${mediaType};base64,${encoded}`;
+}
+function toolResultOutput(output) {
+    switch (output.type) {
+        case "text":
+        case "error-text":
+            return { type: output.type, value: output.value };
+        case "json":
+            return { type: "text", value: JSON.stringify(output.value) };
+        case "error-json":
+            return { type: "error-text", value: JSON.stringify(output.value) };
+        case "execution-denied":
+            return { type: "error-text", value: output.reason ?? "Execution denied" };
+        case "content":
+            return {
+                type: "text",
+                value: output.value
+                    .map((part) => "text" in part && typeof part.text === "string" ? part.text : JSON.stringify(part))
+                    .join("\n"),
+            };
+    }
+}
+function messagesFromCall(call) {
+    const messages = [];
+    const system = [];
+    for (const message of call.prompt) {
+        if (message.role === "system") {
+            system.push(message.content);
+            continue;
+        }
+        if (message.role === "user") {
+            const content = [];
+            for (const part of message.content) {
+                switch (part.type) {
+                    case "text":
+                        content.push({ type: "text", text: part.text });
+                        break;
+                    case "file":
+                        if (part.mediaType.startsWith("image/")) {
+                            content.push({
+                                type: "image",
+                                image: imageData(part.data, part.mediaType),
+                                mimeType: part.mediaType,
+                            });
+                        }
+                        break;
+                }
+            }
+            messages.push({ role: "user", content });
+            continue;
+        }
+        if (message.role === "assistant") {
+            const content = [];
+            for (const part of message.content) {
+                if (part.type === "text" || part.type === "reasoning") {
+                    content.push({ type: part.type, text: part.text });
+                }
+                if (part.type === "tool-call") {
+                    content.push({
+                        type: "tool-call",
+                        toolCallId: part.toolCallId,
+                        toolName: part.toolName,
+                        input: part.input,
+                    });
+                }
+            }
+            messages.push({ role: "assistant", content });
+            continue;
+        }
+        const content = [];
+        for (const part of message.content) {
+            if (part.type !== "tool-result") {
+                continue;
+            }
+            content.push({
+                type: "tool-result",
+                toolCallId: part.toolCallId,
+                toolName: part.toolName,
+                output: toolResultOutput(part.output),
+            });
+        }
+        messages.push({ role: "tool", content });
+    }
+    return { messages, system: system.join("\n\n") };
+}
+function toolsFromCall(call) {
+    const tools = [];
+    for (const tool of call.tools ?? []) {
+        if (tool.type !== "function") {
+            continue;
+        }
+        tools.push({
+            type: "function",
+            name: tool.name,
+            ...(tool.description === undefined ? {} : { description: tool.description }),
+            input_schema: tool.inputSchema,
+        });
+    }
+    return tools;
+}
+export function buildBody(options) {
+    const converted = messagesFromCall(options.call);
+    const workingDir = process.cwd();
+    const params = {
+        model: options.modelId,
+        messages: converted.messages,
+        tools: toolsFromCall(options.call),
+        system: converted.system,
+        max_tokens: options.call.maxOutputTokens ?? 16_384,
+        stream: true,
+    };
+    if (options.call.temperature !== undefined) {
+        params["temperature"] = options.call.temperature;
+    }
+    if (options.call.topP !== undefined) {
+        params["top_p"] = options.call.topP;
+    }
+    if (options.call.topK !== undefined) {
+        params["top_k"] = options.call.topK;
+    }
+    return {
+        config: {
+            workingDir,
+            date: new Date().toISOString().slice(0, 10),
+            environment: `${process.platform}-${process.arch}`,
+            structure: [],
+            isGitRepo: false,
+            currentBranch: "",
+            mainBranch: "",
+            gitStatus: "",
+            recentCommits: [],
+        },
+        memory: "",
+        taste: "",
+        skills: null,
+        permissionMode: "standard",
+        threadId: options.sessionId,
+        params,
+    };
+}

package/dist/providers/command-code/session.d.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+declare const commandCodeSessionIdSchema: z.core.$ZodBranded<z.ZodString, "CommandCodeSessionId">;
+export type CommandCodeSessionId = z.infer<typeof commandCodeSessionIdSchema>;
+export declare function createCommandCodeSessionId(generate?: () => string): CommandCodeSessionId;
+export {};

package/dist/providers/command-code/session.js

@@ -0,0 +1,9 @@
+import { randomUUID } from "node:crypto";
+import { z } from "zod";
+const commandCodeSessionIdSchema = z
+    .string()
+    .uuid()
+    .brand();
+export function createCommandCodeSessionId(generate = randomUUID) {
+    return commandCodeSessionIdSchema.parse(generate());
+}

package/dist/providers/cursor/adapter.d.ts

@@ -0,0 +1,7 @@
+import type { ProviderAdapter } from "../../core/adapter";
+import type { AdapterModel } from "../../core/models";
+export type CursorAdapterOptions = {
+    readonly readAccessToken: (signal: AbortSignal) => Promise<string | null>;
+    readonly listModels: (token: string, signal: AbortSignal) => Promise<readonly AdapterModel[]>;
+};
+export declare function createCursorAdapter(options: CursorAdapterOptions): ProviderAdapter;

package/dist/providers/cursor/adapter.js

@@ -0,0 +1,37 @@
+import { OperationCancelledError } from "../../core/errors";
+import { parseProviderId } from "../../core/ids";
+import { createAsyncDisposable } from "../../core/lifecycle";
+export function createCursorAdapter(options) {
+    const providerId = parseProviderId("cursor");
+    const disposal = createAsyncDisposable(() => undefined);
+    let lastModels = null;
+    return {
+        providerId,
+        snapshot: async (signal) => {
+            if (signal.aborted) {
+                throw new OperationCancelledError("cursor-snapshot");
+            }
+            const token = await options.readAccessToken(signal);
+            if (token === null) {
+                return { status: "unavailable", providerId, reason: "invalid-data" };
+            }
+            try {
+                const models = await options.listModels(token, signal);
+                if (models.length === 0) {
+                    return lastModels === null
+                        ? { status: "unavailable", providerId, reason: "invalid-data" }
+                        : { status: "stale", providerId, models: lastModels, reason: "invalid-data" };
+                }
+                lastModels = models;
+                return { status: "ready", providerId, models };
+            }
+            catch {
+                return lastModels === null
+                    ? { status: "unavailable", providerId, reason: "transport-error" }
+                    : { status: "stale", providerId, models: lastModels, reason: "transport-error" };
+            }
+        },
+        dispose: disposal.dispose,
+        [Symbol.asyncDispose]: disposal[Symbol.asyncDispose],
+    };
+}

package/dist/providers/cursor/auth.d.ts

@@ -0,0 +1,6 @@
+import { type CursorCredentials } from "./credentials";
+export type CursorAuthLookup = {
+    readonly readAuthFile?: (path: string, signal: AbortSignal) => Promise<CursorCredentials | null>;
+};
+export declare function readCursorAccessToken(env: Readonly<Record<string, string | undefined>>, signal: AbortSignal, lookup?: CursorAuthLookup): Promise<string | null>;
+export declare function resolveCursorAgent(env: Readonly<Record<string, string | undefined>>, signal: AbortSignal): Promise<string | null>;

package/dist/providers/cursor/auth.js

@@ -0,0 +1,56 @@
+import { access, readFile } from "node:fs/promises";
+import { delimiter, join } from "node:path";
+import { OperationCancelledError } from "../../core/errors";
+import { parseCursorCredentials } from "./credentials";
+async function defaultReadAuthFile(path, signal) {
+    try {
+        const text = await readFile(path, { encoding: "utf8", signal });
+        return parseCursorCredentials(JSON.parse(text));
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            return null;
+        }
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return null;
+        }
+        throw error;
+    }
+}
+export async function readCursorAccessToken(env, signal, lookup = {}) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("cursor-read-token");
+    }
+    const envToken = env["CURSOR_ACCESS_TOKEN"];
+    if (typeof envToken === "string" && envToken.length > 0) {
+        return envToken;
+    }
+    const home = env["HOME"];
+    if (home === undefined || home.length === 0) {
+        return null;
+    }
+    const readAuthFile = lookup.readAuthFile ?? defaultReadAuthFile;
+    const credentials = await readAuthFile(join(home, ".config/cursor/auth.json"), signal);
+    return credentials === null ? null : credentials.accessToken;
+}
+export async function resolveCursorAgent(env, signal) {
+    if (signal.aborted) {
+        throw new OperationCancelledError("cursor-resolve-agent");
+    }
+    const pathValue = env["PATH"];
+    if (pathValue === undefined || pathValue.length === 0) {
+        return null;
+    }
+    const names = ["cursor-agent", "cursor-agent.exe"];
+    for (const directory of pathValue.split(delimiter)) {
+        for (const name of names) {
+            const candidate = `${directory}/${name}`;
+            try {
+                await access(candidate);
+                return candidate;
+            }
+            catch { }
+        }
+    }
+    return null;
+}

package/dist/providers/cursor/blob-store.d.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { Clock } from "../../core/clock";
+export declare const CursorBlobIdSchema: z.core.$ZodBranded<z.ZodString, "CursorBlobId">;
+export type CursorBlobId = z.output<typeof CursorBlobIdSchema>;
+export type CursorBlobStoreOptions = {
+    readonly clock: Clock;
+    readonly maxBytes: number;
+    readonly maxEntries: number;
+    /** Logical milliseconds; zero expires content on the next store operation. */
+    readonly ttlMs: number;
+};
+export type CursorBlobStore = {
+    readonly get: (blobId: CursorBlobId) => Uint8Array | null;
+    readonly has: (blobId: CursorBlobId) => boolean;
+    readonly hash: (bytes: Uint8Array) => CursorBlobId;
+    readonly pin: (blobId: CursorBlobId) => boolean;
+    readonly put: (bytes: Uint8Array) => CursorBlobId | null;
+    readonly putVerified: (blobId: CursorBlobId, bytes: Uint8Array) => CursorBlobId | null;
+    readonly release: (blobId: CursorBlobId) => void;
+    readonly size: () => number;
+};
+export declare function hashCursorBlob(bytes: Uint8Array): CursorBlobId;
+export declare function parseCursorWireBlobId(bytes: Uint8Array): CursorBlobId;
+export declare function requirePositiveCursorStoreBound(value: number, argument: string): void;
+export declare function requireCursorStoreTtl(value: number): void;
+export declare function createCursorBlobStore(options: CursorBlobStoreOptions): CursorBlobStore;

package/dist/providers/cursor/blob-store.js

@@ -0,0 +1,119 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+import { InvalidArgumentError } from "../../core/errors";
+export const CursorBlobIdSchema = z
+    .string()
+    .regex(/^[a-f0-9]{64}$/)
+    .brand();
+export function hashCursorBlob(bytes) {
+    return CursorBlobIdSchema.parse(createHash("sha256").update(bytes).digest("hex"));
+}
+export function parseCursorWireBlobId(bytes) {
+    if (bytes.byteLength !== 32) {
+        throw new InvalidArgumentError("blobId");
+    }
+    return CursorBlobIdSchema.parse(Buffer.from(bytes).toString("hex"));
+}
+export function requirePositiveCursorStoreBound(value, argument) {
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new InvalidArgumentError(argument);
+    }
+}
+export function requireCursorStoreTtl(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new InvalidArgumentError("ttlMs");
+    }
+}
+export function createCursorBlobStore(options) {
+    requirePositiveCursorStoreBound(options.maxBytes, "maxBytes");
+    requirePositiveCursorStoreBound(options.maxEntries, "maxEntries");
+    requireCursorStoreTtl(options.ttlMs);
+    const entries = new Map();
+    let totalBytes = 0;
+    const evictExpired = (nowMs) => {
+        for (const [blobId, entry] of entries) {
+            if (entry.pins === 0 && nowMs - entry.lastAccessMs >= options.ttlMs) {
+                entries.delete(blobId);
+                totalBytes -= entry.bytes.byteLength;
+            }
+        }
+    };
+    const evictToBounds = () => {
+        while (entries.size > options.maxEntries || totalBytes > options.maxBytes) {
+            let evicted = false;
+            for (const [blobId, entry] of entries) {
+                if (entry.pins === 0) {
+                    entries.delete(blobId);
+                    totalBytes -= entry.bytes.byteLength;
+                    evicted = true;
+                    break;
+                }
+            }
+            if (!evicted) {
+                return;
+            }
+        }
+    };
+    const touch = (blobId, entry, nowMs) => {
+        const updated = { bytes: entry.bytes, lastAccessMs: nowMs, pins: entry.pins };
+        entries.delete(blobId);
+        entries.set(blobId, updated);
+        return updated;
+    };
+    const activeEntry = (blobId) => {
+        const nowMs = options.clock.nowMs();
+        evictExpired(nowMs);
+        const entry = entries.get(blobId);
+        return entry === undefined ? null : touch(blobId, entry, nowMs);
+    };
+    const store = (blobId, bytes) => {
+        const nowMs = options.clock.nowMs();
+        evictExpired(nowMs);
+        if (bytes.byteLength > options.maxBytes) {
+            return null;
+        }
+        const existing = entries.get(blobId);
+        if (existing !== undefined) {
+            touch(blobId, existing, nowMs);
+            return blobId;
+        }
+        const snapshot = new Uint8Array(bytes);
+        entries.set(blobId, { bytes: snapshot, lastAccessMs: nowMs, pins: 0 });
+        totalBytes += snapshot.byteLength;
+        evictToBounds();
+        return entries.has(blobId) ? blobId : null;
+    };
+    return {
+        get: (blobId) => {
+            const entry = activeEntry(blobId);
+            return entry === null ? null : new Uint8Array(entry.bytes);
+        },
+        has: (blobId) => activeEntry(blobId) !== null,
+        hash: hashCursorBlob,
+        pin: (blobId) => {
+            const entry = activeEntry(blobId);
+            if (entry === null) {
+                return false;
+            }
+            entry.pins += 1;
+            return true;
+        },
+        put: (bytes) => store(hashCursorBlob(bytes), bytes),
+        putVerified: (blobId, bytes) => {
+            if (hashCursorBlob(bytes) !== blobId) {
+                throw new InvalidArgumentError("blobId");
+            }
+            return store(blobId, bytes);
+        },
+        release: (blobId) => {
+            const entry = entries.get(blobId);
+            if (entry !== undefined && entry.pins > 0) {
+                entry.pins -= 1;
+            }
+        },
+        size: () => {
+            evictExpired(options.clock.nowMs());
+            return entries.size;
+        },
+    };
+}

package/dist/providers/cursor/bridge-client.d.ts

@@ -0,0 +1,33 @@
+import { type CursorBridgeProcessFactory } from "./bridge-process";
+import { type BridgeEvent } from "./bridge-protocol";
+export type CursorBridgeSessionErrorReason = "duplicate-stream" | "stream-closed";
+export declare class CursorBridgeSessionError extends Error {
+    readonly reason: CursorBridgeSessionErrorReason;
+    readonly name = "CursorBridgeSessionError";
+    readonly code = "CURSOR_BRIDGE_SESSION_ERROR";
+    constructor(reason: CursorBridgeSessionErrorReason);
+}
+export type CursorBridgeOpenInput = {
+    readonly id: string;
+    readonly accessToken: string;
+    readonly path: string;
+    readonly headers: Readonly<Record<string, string>>;
+    readonly signal: AbortSignal;
+};
+export interface CursorBridgeStream {
+    readonly id: string;
+    write(payload: Uint8Array, signal?: AbortSignal): Promise<void>;
+    nextEvent(signal?: AbortSignal): Promise<BridgeEvent>;
+    abort(): Promise<void>;
+    close(): Promise<void>;
+}
+export interface CursorBridgeClient extends AsyncDisposable {
+    readonly pid: number;
+    open(input: CursorBridgeOpenInput): Promise<CursorBridgeStream>;
+    dispose(): Promise<void>;
+}
+export type CursorBridgeClientOptions = {
+    readonly processFactory?: CursorBridgeProcessFactory;
+    readonly signal?: AbortSignal;
+};
+export declare function createCursorBridgeClient(options?: CursorBridgeClientOptions): Promise<CursorBridgeClient>;