cursor-opencode-provider 0.1.1

package/dist/protocol/client-version.js

@@ -0,0 +1,150 @@
+import fs from "node:fs";
+import path from "node:path";
+import { FALLBACK_CLIENT_VERSION, MODEL_CACHE_TTL_MS, VERSION_CACHE_FILE, } from "../shared.js";
+const INSTALL_URL = "https://cursor.com/install";
+const REMOTE_TIMEOUT_MS = 5_000;
+const BUILD_RE = /^\d{4}\.\d{2}\.\d{2}-[0-9A-Za-z][0-9A-Za-z.-]*$/;
+const CLIENT_VERSION_RE = /^cli-[0-9A-Za-z][0-9A-Za-z._-]*$/;
+let cachedResolution;
+export function resetClientVersionCache() {
+    cachedResolution = undefined;
+}
+export function resolveClientVersion() {
+    cachedResolution ??= resolve();
+    return cachedResolution;
+}
+async function resolve() {
+    const env = process.env.CURSOR_CLIENT_VERSION?.trim();
+    if (isClientVersion(env))
+        return env;
+    const local = discoverLocalVersion();
+    if (local)
+        return local;
+    return (await resolveRemoteVersion()) ?? FALLBACK_CLIENT_VERSION;
+}
+function isClientVersion(value) {
+    return typeof value === "string" && CLIENT_VERSION_RE.test(value);
+}
+export function cursorAgentVersionsDir() {
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home)
+        return undefined;
+    switch (process.platform) {
+        case "linux":
+        case "darwin":
+            return path.join(home, ".local", "share", "cursor-agent", "versions");
+        default:
+            return undefined;
+    }
+}
+export function discoverLocalVersion(dir = cursorAgentVersionsDir()) {
+    if (!dir)
+        return undefined;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    let newest;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !BUILD_RE.test(entry.name))
+            continue;
+        try {
+            const mtimeMs = fs.statSync(path.join(dir, entry.name)).mtimeMs;
+            if (!newest ||
+                mtimeMs > newest.mtimeMs ||
+                (mtimeMs === newest.mtimeMs && entry.name > newest.name)) {
+                newest = { name: entry.name, mtimeMs };
+            }
+        }
+        catch {
+            // Directory disappeared during discovery.
+        }
+    }
+    return newest ? `cli-${newest.name}` : undefined;
+}
+export function extractVersionFromInstaller(script) {
+    const match = script.match(/downloads\.cursor\.com\/lab\/([^/"'\s]+)\//);
+    return match && BUILD_RE.test(match[1]) ? match[1] : undefined;
+}
+function resolveCacheDir() {
+    if (process.env.CURSOR_CONFIG_DIR)
+        return process.env.CURSOR_CONFIG_DIR;
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (!home)
+        return undefined;
+    return process.env.XDG_CONFIG_HOME
+        ? path.join(process.env.XDG_CONFIG_HOME, "opencode")
+        : path.join(home, ".config", "opencode");
+}
+function versionCachePath() {
+    const dir = resolveCacheDir();
+    return dir ? path.join(dir, VERSION_CACHE_FILE) : undefined;
+}
+function readVersionCache() {
+    const file = versionCachePath();
+    if (!file)
+        return undefined;
+    try {
+        const value = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (!isClientVersion(value.version) ||
+            typeof value.fetchedAt !== "number" ||
+            !Number.isFinite(value.fetchedAt)) {
+            return undefined;
+        }
+        return { version: value.version, fetchedAt: value.fetchedAt };
+    }
+    catch {
+        return undefined;
+    }
+}
+function writeVersionCache(cache) {
+    const file = versionCachePath();
+    if (!file)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, JSON.stringify(cache, null, 2));
+    }
+    catch {
+        // Cache writes are optional.
+    }
+}
+function isCacheFresh(cache, now = Date.now()) {
+    const age = now - cache.fetchedAt;
+    return age >= 0 && age < MODEL_CACHE_TTL_MS;
+}
+async function fetchInstallerVersion() {
+    const response = await fetch(INSTALL_URL, {
+        signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS),
+    });
+    if (!response.ok)
+        return undefined;
+    const build = extractVersionFromInstaller(await response.text());
+    return build ? `cli-${build}` : undefined;
+}
+async function refreshVersionCache() {
+    const version = await fetchInstallerVersion();
+    if (version)
+        writeVersionCache({ version, fetchedAt: Date.now() });
+}
+async function resolveRemoteVersion() {
+    const cached = readVersionCache();
+    if (cached && isCacheFresh(cached)) {
+        void refreshVersionCache().catch(() => { });
+        return cached.version;
+    }
+    try {
+        const version = await fetchInstallerVersion();
+        if (version) {
+            writeVersionCache({ version, fetchedAt: Date.now() });
+            return version;
+        }
+    }
+    catch {
+        // Use stale cache or the fallback below.
+    }
+    return cached?.version;
+}

package/dist/protocol/device-id.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Stable device fingerprints, derived exactly like the Cursor CLI.
+ * Cached for the process lifetime after first computation.
+ */
+export declare function getDeviceIds(): {
+    machineId: string;
+    macMachineId?: string;
+};

package/dist/protocol/device-id.js

@@ -0,0 +1,121 @@
+import crypto from "node:crypto";
+import os from "node:os";
+import fs from "node:fs";
+import { execSync } from "node:child_process";
+// Device fingerprints MUST be stable across restarts: Cursor keys "device
+// identity" off the ids embedded in x-cursor-checksum, and treats every new
+// machineId as a separate device ("too many connections from different
+// devices"). The real Cursor CLI derives these from stable OS identifiers
+// (IOPlatformUUID / MAC address) rather than persisting them, so recomputing
+// each launch yields the SAME value forever on a given machine. We replicate
+// that derivation verbatim so we present exactly one device, matching the CLI.
+//
+// Source: cursor-agent-extracted — machineId = sha256(IOPlatformUUID) with a
+// MAC/hostname fallback; macMachineId = sha256(first non-zero MAC).
+let _cached;
+function sha256hex(s) {
+    return crypto.createHash("sha256").update(s, "utf8").digest("hex");
+}
+// macOS: `ioreg -rd1 -c IOPlatformExpertDevice` → IOPlatformUUID, parsed and
+// normalised exactly as the CLI does.
+function readMacOSUUID() {
+    try {
+        const out = execSync("ioreg -rd1 -c IOPlatformExpertDevice", {
+            timeout: 5000,
+        }).toString();
+        const after = out.split("IOPlatformUUID")[1];
+        if (!after)
+            return undefined;
+        return after
+            .split("\n")[0]
+            .replace(/=|\s+|"/gi, "")
+            .toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+// Linux: machine-id files (stable, per-install).
+function readLinuxMachineId() {
+    for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+        try {
+            const v = fs.readFileSync(p, "utf8");
+            if (v)
+                return v.trim();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return undefined;
+}
+// Windows: MachineGuid from the registry.
+function readWindowsMachineGuid() {
+    try {
+        const out = execSync('reg query "HKLM\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid', { timeout: 5000 }).toString();
+        const m = out.split("MachineGuid")[1];
+        if (!m)
+            return undefined;
+        const hex = m.replace(/=|\s+|"/gi, "");
+        return hex || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function platformUuid() {
+    switch (process.platform) {
+        case "darwin":
+            return readMacOSUUID();
+        case "linux":
+            return readLinuxMachineId();
+        case "win32":
+            return readWindowsMachineGuid();
+        default:
+            return undefined;
+    }
+}
+// First non-zero MAC address across all interfaces (matches CLI's $e()).
+function firstMacAddress() {
+    try {
+        const ifaces = os.networkInterfaces();
+        for (const list of Object.values(ifaces)) {
+            if (!list)
+                continue;
+            for (const ni of list) {
+                if (ni && ni.mac && ni.mac !== "00:00:00:00:00:00")
+                    return ni.mac;
+            }
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return undefined;
+}
+/**
+ * Stable device fingerprints, derived exactly like the Cursor CLI.
+ * Cached for the process lifetime after first computation.
+ */
+export function getDeviceIds() {
+    if (_cached)
+        return _cached;
+    const mac = firstMacAddress();
+    const uuid = platformUuid();
+    // machineId: sha256(platform UUID); fall back to sha256(MAC) then hostname,
+    // mirroring the CLI's Xe() fallback chain.
+    let machineId;
+    if (uuid) {
+        machineId = sha256hex(uuid);
+    }
+    else if (mac) {
+        machineId = sha256hex(mac);
+    }
+    else {
+        machineId = sha256hex(os.hostname());
+    }
+    // macMachineId: sha256(MAC), or undefined if no interface MAC is available.
+    const macMachineId = mac ? sha256hex(mac) : undefined;
+    _cached = { machineId, macMachineId };
+    return _cached;
+}

package/dist/protocol/framing.d.ts

@@ -0,0 +1,10 @@
+export declare const FLAG_GZIP = 1;
+export declare const FLAG_END_STREAM = 2;
+export type Frame = {
+    flags: number;
+    payload: Uint8Array;
+};
+export declare function encodeFrame(flags: number, payload: Uint8Array): Uint8Array;
+export declare function decodeFramePayload(frame: Frame): Uint8Array;
+export declare function streamFrames(buffer: Uint8Array): Generator<Frame, void, void>;
+export declare function asyncStreamFrames(stream: ReadableStream<Uint8Array>): AsyncGenerator<Frame, void, void>;

package/dist/protocol/framing.js

@@ -0,0 +1,90 @@
+import { gunzipSync, gzipSync } from "node:zlib";
+export const FLAG_GZIP = 0x01;
+export const FLAG_END_STREAM = 0x02;
+export function encodeFrame(flags, payload) {
+    let data = payload;
+    if (flags & FLAG_GZIP) {
+        data = gzipSync(data);
+    }
+    const len = data.length;
+    const header = new Uint8Array(5);
+    header[0] = flags;
+    header[1] = (len >> 24) & 0xff;
+    header[2] = (len >> 16) & 0xff;
+    header[3] = (len >> 8) & 0xff;
+    header[4] = len & 0xff;
+    const out = new Uint8Array(5 + len);
+    out.set(header, 0);
+    out.set(data, 5);
+    return out;
+}
+export function decodeFramePayload(frame) {
+    return frame.flags & FLAG_GZIP ? gunzipSync(frame.payload) : frame.payload;
+}
+export function* streamFrames(buffer) {
+    let offset = 0;
+    while (offset + 5 <= buffer.length) {
+        const flags = buffer[offset];
+        const len = ((buffer[offset + 1] << 24) |
+            (buffer[offset + 2] << 16) |
+            (buffer[offset + 3] << 8) |
+            buffer[offset + 4]) >>> 0;
+        const start = offset + 5;
+        if (start + len > buffer.length)
+            break;
+        yield { flags, payload: buffer.subarray(start, start + len) };
+        offset = start + len;
+    }
+}
+export async function* asyncStreamFrames(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    let pendingLength = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done && chunks.length === 0)
+                return;
+            if (value) {
+                chunks.push(value);
+                pendingLength += value.length;
+            }
+            // Try to parse frames from accumulated data
+            const merged = mergeChunks(chunks);
+            const frames = Array.from(streamFrames(merged));
+            const consumed = frames.reduce((sum, f) => sum + 5 + f.payload.length, 0);
+            if (frames.length > 0) {
+                for (const frame of frames) {
+                    yield frame;
+                }
+                // Keep any trailing bytes for next iteration
+                const remaining = merged.subarray(consumed);
+                chunks.length = 0;
+                if (remaining.length > 0) {
+                    chunks.push(remaining);
+                    pendingLength = remaining.length;
+                }
+                else {
+                    pendingLength = 0;
+                }
+            }
+            if (done)
+                return;
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+function mergeChunks(chunks) {
+    if (chunks.length === 1)
+        return chunks[0];
+    const total = chunks.reduce((s, c) => s + c.length, 0);
+    const merged = new Uint8Array(total);
+    let offset = 0;
+    for (const c of chunks) {
+        merged.set(c, offset);
+        offset += c.length;
+    }
+    return merged;
+}

package/dist/protocol/kv.d.ts

@@ -0,0 +1,24 @@
+import type { CursorSession } from "../session.js";
+/**
+ * Handle a server `KvServerMessage` (AgentServerMessage #4). Cursor moves large
+ * payloads out-of-band via this blob channel:
+ *  - `set_blob_args{blob_id, blob_data}` → server stores a blob on the client.
+ *    We persist it (per-session + durable per conversation_id) and ACK.
+ *  - `get_blob_args{blob_id}` → server asks the client for a blob it stored.
+ *    We return `get_blob_result{blob_data}` (empty if unknown hash).
+ * The reply MUST be sent as `AgentClientMessage.kv_client_message` (field #3) on
+ * the same Run stream, echoing `id`. If we don't reply, the server hangs the
+ * turn (endless heartbeats, never any interaction_update) — the "no response"
+ * root cause.
+ *
+ * Returns the AgentClientMessage bytes to write back, or null if the message
+ * carried no get/set blob request.
+ */
+export declare function handleKvServerMessage(ksm: Record<string, unknown>, session: CursorSession): {
+    reply: Uint8Array;
+    kind: "set" | "get";
+    id: number;
+    blobIdHex: string;
+    found: boolean;
+    echoed?: boolean;
+} | null;

package/dist/protocol/kv.js

@@ -0,0 +1,81 @@
+import { encodeMessage } from "./messages.js";
+import { getConversationBlob, isBlobIdHash, setConversationBlob, } from "./blob-store.js";
+function hex(b) {
+    let s = "";
+    for (let i = 0; i < b.length; i++)
+        s += b[i].toString(16).padStart(2, "0");
+    return s;
+}
+/**
+ * Handle a server `KvServerMessage` (AgentServerMessage #4). Cursor moves large
+ * payloads out-of-band via this blob channel:
+ *  - `set_blob_args{blob_id, blob_data}` → server stores a blob on the client.
+ *    We persist it (per-session + durable per conversation_id) and ACK.
+ *  - `get_blob_args{blob_id}` → server asks the client for a blob it stored.
+ *    We return `get_blob_result{blob_data}` (empty if unknown hash).
+ * The reply MUST be sent as `AgentClientMessage.kv_client_message` (field #3) on
+ * the same Run stream, echoing `id`. If we don't reply, the server hangs the
+ * turn (endless heartbeats, never any interaction_update) — the "no response"
+ * root cause.
+ *
+ * Returns the AgentClientMessage bytes to write back, or null if the message
+ * carried no get/set blob request.
+ */
+export function handleKvServerMessage(ksm, session) {
+    const id = ksm.id ?? 0;
+    const setArgs = ksm.set_blob_args;
+    const getArgs = ksm.get_blob_args;
+    if (setArgs && setArgs.blob_id) {
+        const data = setArgs.blob_data ?? new Uint8Array(0);
+        const key = hex(setArgs.blob_id);
+        session.blobs.set(key, data);
+        // Survive across Run streams — required for checkpoint echo on turn 2+.
+        if (session.conversationId) {
+            setConversationBlob(session.conversationId, setArgs.blob_id, data);
+        }
+        return {
+            kind: "set",
+            id,
+            blobIdHex: key,
+            found: true,
+            reply: encodeMessage("AgentClientMessage", {
+                kv_client_message: { id, set_blob_result: {} },
+            }),
+        };
+    }
+    if (getArgs && getArgs.blob_id) {
+        const key = hex(getArgs.blob_id);
+        const stored = session.blobs.get(key) ??
+            (session.conversationId
+                ? getConversationBlob(session.conversationId, getArgs.blob_id)
+                : undefined);
+        let blobData;
+        let echoed = false;
+        let found = false;
+        if (stored) {
+            blobData = stored;
+            found = true;
+        }
+        else if (!isBlobIdHash(getArgs.blob_id)) {
+            // Content-as-id: server sometimes sends blob_id as the literal payload
+            // (e.g. inline JSON). Echo it. Never do this for 32-byte hashes — that
+            // made the server JSON.parse binary and return "Unexpected token".
+            blobData = getArgs.blob_id;
+            echoed = true;
+        }
+        else {
+            blobData = new Uint8Array(0);
+        }
+        return {
+            kind: "get",
+            id,
+            blobIdHex: key,
+            found,
+            echoed,
+            reply: encodeMessage("AgentClientMessage", {
+                kv_client_message: { id, get_blob_result: { blob_data: blobData } },
+            }),
+        };
+    }
+    return null;
+}

package/dist/protocol/messages.d.ts

@@ -0,0 +1,11 @@
+import protobuf from "protobufjs";
+export declare function createMessageTypes(): protobuf.Root;
+export declare function getMessageTypes(): protobuf.Root;
+export declare function encodeMessage(typeName: string, message: Record<string, unknown>): Uint8Array;
+export declare function decodeMessage<T = Record<string, unknown>>(typeName: string, data: Uint8Array): T;
+/**
+ * Decode a protobuf sub-message from a frame payload that wraps it in
+ * a top-level field key + length varint.  Skips the outer wrapper and
+ * decodes the inner body as `typeName`.
+ */
+export declare function decodeWrappedMessage<T = Record<string, unknown>>(typeName: string, data: Uint8Array): T;