@rama_nigg/open-cursor 2.1.2

package/dist/cli/opencode-cursor.js

@@ -0,0 +1,430 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/errors.ts
+function stripAnsi(str) {
+  if (typeof str !== "string")
+    return String(str ?? "");
+  return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+function parseAgentError(stderr) {
+  const input = typeof stderr === "string" ? stderr : String(stderr ?? "");
+  const clean = stripAnsi(input).trim();
+  if (clean.includes("usage limit") || clean.includes("hit your usage limit")) {
+    const savingsMatch = clean.match(/saved \$(\d+(?:\.\d+)?)/i);
+    const resetMatch = clean.match(/reset[^0-9]*(\d{1,2}\/\d{1,2}\/\d{4})/i);
+    const modelMatch = clean.match(/continue with (\w+)/i);
+    const details = {};
+    if (savingsMatch)
+      details.savings = `$${savingsMatch[1]}`;
+    if (resetMatch)
+      details.resetDate = resetMatch[1];
+    if (modelMatch)
+      details.affectedModel = modelMatch[1];
+    return {
+      type: "quota",
+      recoverable: false,
+      message: clean,
+      userMessage: "You've hit your Cursor usage limit",
+      details,
+      suggestion: "Switch to a different model or set a Spend Limit in Cursor settings"
+    };
+  }
+  if (clean.includes("not logged in") || clean.includes("auth") || clean.includes("unauthorized")) {
+    return {
+      type: "auth",
+      recoverable: false,
+      message: clean,
+      userMessage: "Not authenticated with Cursor",
+      details: {},
+      suggestion: "Run: opencode auth login → Other → cursor-acp, or: cursor-agent login"
+    };
+  }
+  if (clean.includes("ECONNREFUSED") || clean.includes("network") || clean.includes("fetch failed")) {
+    return {
+      type: "network",
+      recoverable: true,
+      message: clean,
+      userMessage: "Connection to Cursor failed",
+      details: {},
+      suggestion: "Check your internet connection and try again"
+    };
+  }
+  if (clean.includes("model not found") || clean.includes("invalid model") || clean.includes("Cannot use this model")) {
+    const modelMatch = clean.match(/Cannot use this model: ([^.]+)/);
+    const availableMatch = clean.match(/Available models: (.+)/);
+    const details = {};
+    if (modelMatch)
+      details.requested = modelMatch[1];
+    if (availableMatch)
+      details.available = availableMatch[1].split(", ").slice(0, 5).join(", ") + "...";
+    return {
+      type: "model",
+      recoverable: false,
+      message: clean,
+      userMessage: modelMatch ? `Model '${modelMatch[1]}' not available` : "Requested model not available",
+      details,
+      suggestion: "Use cursor-acp/auto or check available models with: cursor-agent models"
+    };
+  }
+  const recoverable = clean.includes("timeout") || clean.includes("ETIMEDOUT");
+  return {
+    type: "unknown",
+    recoverable,
+    message: clean,
+    userMessage: clean.substring(0, 200) || "An error occurred",
+    details: {}
+  };
+}
+function formatErrorForUser(error) {
+  let output = `cursor-acp error: ${error.userMessage || error.message || "Unknown error"}`;
+  const details = error.details || {};
+  if (Object.keys(details).length > 0) {
+    const detailParts = Object.entries(details).map(([k, v]) => `${k}: ${v}`).join(" | ");
+    output += `
+  ${detailParts}`;
+  }
+  if (error.suggestion) {
+    output += `
+  Suggestion: ${error.suggestion}`;
+  }
+  return output;
+}
+
+// src/cli/opencode-cursor.ts
+import { execFileSync as execFileSync2 } from "child_process";
+import {
+  copyFileSync,
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+
+// src/cli/model-discovery.ts
+import { execFileSync } from "child_process";
+function parseCursorModelsOutput(output) {
+  const clean = stripAnsi(output);
+  const models = [];
+  const seen = new Set;
+  for (const line of clean.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    const match = trimmed.match(/^([a-zA-Z0-9._-]+)\s+-\s+(.+?)(?:\s+\((?:current|default)\))*\s*$/);
+    if (!match)
+      continue;
+    const id = match[1];
+    if (seen.has(id))
+      continue;
+    seen.add(id);
+    models.push({ id, name: match[2].trim() });
+  }
+  return models;
+}
+function discoverModelsFromCursorAgent() {
+  const raw = execFileSync("cursor-agent", ["models"], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const models = parseCursorModelsOutput(raw);
+  if (models.length === 0) {
+    throw new Error("No models parsed from cursor-agent output");
+  }
+  return models;
+}
+function fallbackModels() {
+  return [
+    { id: "auto", name: "Auto" },
+    { id: "sonnet-4.5", name: "Claude 4.5 Sonnet" },
+    { id: "opus-4.6", name: "Claude 4.6 Opus" },
+    { id: "gpt-5.2", name: "GPT-5.2" }
+  ];
+}
+
+// src/cli/opencode-cursor.ts
+var PROVIDER_ID = "cursor-acp";
+var DEFAULT_BASE_URL = "http://127.0.0.1:32124/v1";
+function printHelp() {
+  console.log(`opencode-cursor
+
+Usage:
+  opencode-cursor install [--config <path>] [--plugin-dir <path>] [--base-url <url>] [--copy] [--skip-models] [--no-backup]
+  opencode-cursor sync-models [--config <path>] [--no-backup]
+  opencode-cursor uninstall [--config <path>] [--plugin-dir <path>] [--no-backup]
+  opencode-cursor status [--config <path>] [--plugin-dir <path>]
+  opencode-cursor help
+`);
+}
+function parseArgs(argv) {
+  const [commandRaw, ...rest] = argv;
+  const command = normalizeCommand(commandRaw);
+  const options = {};
+  for (let i = 0;i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (arg === "--copy") {
+      options.copy = true;
+    } else if (arg === "--skip-models") {
+      options.skipModels = true;
+    } else if (arg === "--no-backup") {
+      options.noBackup = true;
+    } else if (arg === "--config" && rest[i + 1]) {
+      options.config = rest[i + 1];
+      i += 1;
+    } else if (arg === "--plugin-dir" && rest[i + 1]) {
+      options.pluginDir = rest[i + 1];
+      i += 1;
+    } else if (arg === "--base-url" && rest[i + 1]) {
+      options.baseUrl = rest[i + 1];
+      i += 1;
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+  return { command, options };
+}
+function normalizeCommand(value) {
+  switch ((value || "install").toLowerCase()) {
+    case "install":
+    case "sync-models":
+    case "uninstall":
+    case "status":
+    case "help":
+      return value ? value.toLowerCase() : "install";
+    default:
+      throw new Error(`Unknown command: ${value}`);
+  }
+}
+function getConfigHome() {
+  const xdg = process.env.XDG_CONFIG_HOME;
+  if (xdg && xdg.length > 0)
+    return xdg;
+  return join(homedir(), ".config");
+}
+function resolvePaths(options) {
+  const opencodeDir = join(getConfigHome(), "opencode");
+  const configPath = resolve(options.config || join(opencodeDir, "opencode.json"));
+  const pluginDir = resolve(options.pluginDir || join(opencodeDir, "plugin"));
+  const pluginPath = join(pluginDir, `${PROVIDER_ID}.js`);
+  return { opencodeDir, configPath, pluginDir, pluginPath };
+}
+function resolvePluginSource() {
+  const currentFile = fileURLToPath(import.meta.url);
+  const currentDir = dirname(currentFile);
+  const candidates = [
+    join(currentDir, "plugin-entry.js"),
+    join(currentDir, "..", "plugin-entry.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error("Unable to locate plugin-entry.js next to CLI distribution files");
+}
+function readConfig(configPath) {
+  if (!existsSync(configPath)) {
+    return { plugin: [], provider: {} };
+  }
+  const raw = readFileSync(configPath, "utf8");
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Invalid JSON in config: ${configPath} (${String(error)})`);
+  }
+}
+function writeConfig(configPath, config, noBackup) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  if (!noBackup && existsSync(configPath)) {
+    const backupPath = `${configPath}.bak.${new Date().toISOString().replace(/[:]/g, "-")}`;
+    copyFileSync(configPath, backupPath);
+    console.log(`Backup written: ${backupPath}`);
+  }
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+}
+function ensureProvider(config, baseUrl) {
+  config.plugin = Array.isArray(config.plugin) ? config.plugin : [];
+  if (!config.plugin.includes(PROVIDER_ID)) {
+    config.plugin.push(PROVIDER_ID);
+  }
+  config.provider = config.provider && typeof config.provider === "object" ? config.provider : {};
+  const current = config.provider[PROVIDER_ID] && typeof config.provider[PROVIDER_ID] === "object" ? config.provider[PROVIDER_ID] : {};
+  const options = current.options && typeof current.options === "object" ? current.options : {};
+  const models = current.models && typeof current.models === "object" ? current.models : {};
+  config.provider[PROVIDER_ID] = {
+    ...current,
+    name: "Cursor",
+    npm: "@ai-sdk/openai-compatible",
+    options: {
+      ...options,
+      baseURL: baseUrl
+    },
+    models
+  };
+}
+function ensurePluginLink(pluginSource, pluginPath, copyMode) {
+  mkdirSync(dirname(pluginPath), { recursive: true });
+  rmSync(pluginPath, { force: true });
+  if (copyMode) {
+    copyFileSync(pluginSource, pluginPath);
+    return;
+  }
+  symlinkSync(pluginSource, pluginPath);
+}
+function discoverModelsSafe() {
+  try {
+    return discoverModelsFromCursorAgent();
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: cursor-agent models failed; using fallback models (${message})`);
+    return fallbackModels();
+  }
+}
+function installAiSdk(opencodeDir) {
+  try {
+    execFileSync2("bun", ["install", "@ai-sdk/openai-compatible"], {
+      cwd: opencodeDir,
+      stdio: "inherit"
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.warn(`Warning: failed to install @ai-sdk/openai-compatible via bun (${message})`);
+  }
+}
+function commandInstall(options) {
+  const { opencodeDir, configPath, pluginPath } = resolvePaths(options);
+  const baseUrl = options.baseUrl || DEFAULT_BASE_URL;
+  const copyMode = options.copy === true;
+  const pluginSource = resolvePluginSource();
+  mkdirSync(opencodeDir, { recursive: true });
+  ensurePluginLink(pluginSource, pluginPath, copyMode);
+  const config = readConfig(configPath);
+  ensureProvider(config, baseUrl);
+  if (!options.skipModels) {
+    const models = discoverModelsSafe();
+    for (const model of models) {
+      config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
+    }
+    console.log(`Models synced: ${models.length}`);
+  }
+  writeConfig(configPath, config, options.noBackup === true);
+  installAiSdk(opencodeDir);
+  console.log(`Installed ${PROVIDER_ID}`);
+  console.log(`Plugin path: ${pluginPath}${copyMode ? " (copy)" : " (symlink)"}`);
+  console.log(`Config path: ${configPath}`);
+}
+function commandSyncModels(options) {
+  const { configPath } = resolvePaths(options);
+  const config = readConfig(configPath);
+  ensureProvider(config, options.baseUrl || DEFAULT_BASE_URL);
+  const models = discoverModelsSafe();
+  for (const model of models) {
+    config.provider[PROVIDER_ID].models[model.id] = { name: model.name };
+  }
+  writeConfig(configPath, config, options.noBackup === true);
+  console.log(`Models synced: ${models.length}`);
+  console.log(`Config path: ${configPath}`);
+}
+function commandUninstall(options) {
+  const { configPath, pluginPath } = resolvePaths(options);
+  rmSync(pluginPath, { force: true });
+  if (existsSync(configPath)) {
+    const config = readConfig(configPath);
+    if (Array.isArray(config.plugin)) {
+      config.plugin = config.plugin.filter((name) => name !== PROVIDER_ID);
+    }
+    if (config.provider && typeof config.provider === "object") {
+      delete config.provider[PROVIDER_ID];
+    }
+    writeConfig(configPath, config, options.noBackup === true);
+  }
+  console.log(`Removed plugin link: ${pluginPath}`);
+  console.log(`Removed provider "${PROVIDER_ID}" from ${configPath}`);
+}
+function commandStatus(options) {
+  const { configPath, pluginPath } = resolvePaths(options);
+  const pluginExists = existsSync(pluginPath);
+  const pluginType = pluginExists ? lstatSync(pluginPath).isSymbolicLink() ? "symlink" : "file" : "missing";
+  let providerExists = false;
+  let pluginEnabled = false;
+  if (existsSync(configPath)) {
+    const config = readConfig(configPath);
+    providerExists = Boolean(config.provider?.[PROVIDER_ID]);
+    pluginEnabled = Array.isArray(config.plugin) && config.plugin.includes(PROVIDER_ID);
+  }
+  console.log(`Plugin file: ${pluginPath} (${pluginType})`);
+  console.log(`Provider in config: ${providerExists ? "yes" : "no"}`);
+  console.log(`Plugin enabled in config: ${pluginEnabled ? "yes" : "no"}`);
+  console.log(`Config path: ${configPath}`);
+}
+function main() {
+  let parsed;
+  try {
+    parsed = parseArgs(process.argv.slice(2));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    printHelp();
+    process.exit(1);
+    return;
+  }
+  try {
+    switch (parsed.command) {
+      case "install":
+        commandInstall(parsed.options);
+        return;
+      case "sync-models":
+        commandSyncModels(parsed.options);
+        return;
+      case "uninstall":
+        commandUninstall(parsed.options);
+        return;
+      case "status":
+        commandStatus(parsed.options);
+        return;
+      case "help":
+        printHelp();
+        return;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  }
+}
+main();