@kesarcloud/omega-plus-cli 2.0.4 → 2.0.6

package/README.md

@@ -30,8 +30,8 @@ Defaults:
 - OpenAI-compatible URL: `https://omega.kesarcloud.in/api/v1`
 - Anthropic-compatible URL: `https://omega.kesarcloud.in/v1`
 - API key validation URL: `https://omega.kesarcloud.in/api/omega/validate-key`
-- Model: `omega-v1-pro`
-- Fast model: `omega-v1`
+- Model: `omega-plus` (default)
+- Additional models: `KesarCloud/anthropic/claude-opus-4-6`, `KesarCloud/anthropic/claude-opus-4.7`, `KesarCloud/openai/gpt-5.5`
 
 Use `--base-url`, `--openai-base-url`, `--anthropic-base-url`, `--model`, or `--fast-model` to override them.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kesarcloud/omega-plus-cli",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Interactive Omega Plus setup wizard for coding CLI tools.",
   "type": "module",
   "bin": {
@@ -18,7 +18,9 @@
   },
   "keywords": [
     "omega-plus",
-    "omega-v1",
+    "claude-opus-4-6",
+    "claude-opus-4-7",
+    "gpt-5-5",
     "claude-code",
     "codex",
     "opencode",

package/src/cli.mjs

@@ -7,21 +7,26 @@ import {
   DEFAULT_VALIDATION_URL,
   VERSION,
 } from "./constants.mjs";
-import { printDoctor, printToolList, runNonInteractiveConfigure, runWizard } from "./wizard.mjs";
+import { printDoctor, printToolList, runNonInteractiveConfigure, runWizard, runUpdateFlow } from "./wizard.mjs";
+import { scanForMigration, migrateAllTools } from "./migrate.mjs";
 
 function printHelp() {
   console.log(`Omega Plus CLI ${VERSION}
 
 Usage:
-  omega-plus
-  omega-plus setup
+  omega-plus                       Interactive setup wizard
+  omega-plus setup                 New setup with menu
+  omega-plus update                Update existing tool configs
   omega-plus configure --tool <id> --api-key <key>
-  omega-plus list
-  omega-plus doctor
+  omega-plus list                  List tools and status
+  omega-plus doctor                Diagnostic info
+  omega-plus docs                  Open documentation
+  omega-plus migrate               Migrate old configs
 
 Options:
   --api-key <key>       Omega API key
   --tool <id>           claude, codex, opencode, cline, kilo, droid
+  --update              Skip menu and go directly to update flow
   --base-url <url>      Default: ${DEFAULT_BASE_URL}
   --openai-base-url     Codex/OpenAI-compatible default: ${DEFAULT_OPENAI_BASE_URL}
   --anthropic-base-url  Anthropic-compatible default: ${DEFAULT_ANTHROPIC_BASE_URL}
@@ -30,8 +35,10 @@ Options:
   --fast-model <id>     Default: ${DEFAULT_FAST_MODEL}
   --skip-key-validation Skip server-side API key validation
   --dry-run             Preview files without writing
-  --yes                 Auto-confirm install prompts
+  --yes                 Auto-confirm prompts
   --no-install          Do not install missing tools
+  --migrate-all         Auto-migrate old omega-v1 configs
+  --skip-migration-check Skip stale config detection
   --help                Show help
   --version             Show version
 `);
@@ -50,6 +57,9 @@ function parseArgs(argv) {
     else if (arg === "--skip-key-validation") options.skipKeyValidation = true;
     else if (arg === "--yes" || arg === "-y") options.yes = true;
     else if (arg === "--no-install") options.noInstall = true;
+    else if (arg === "--migrate-all") options.migrateAll = true;
+    else if (arg === "--skip-migration-check") options.skipMigrationCheck = true;
+    else if (arg === "--update") options.update = true;
     else if (arg === "--api-key") options.apiKey = args[++i];
     else if (arg.startsWith("--api-key=")) options.apiKey = arg.slice("--api-key=".length);
     else if (arg === "--tool") options.tool = args[++i];
@@ -90,6 +100,14 @@ export async function main(argv = process.argv.slice(2)) {
     case "setup":
       await runWizard(options);
       break;
+    case "update":
+      options.update = true;
+      await runWizard(options);
+      break;
+    case "docs":
+      options.command = "docs";
+      await runWizard(options);
+      break;
     case "configure":
       await runNonInteractiveConfigure(options);
       break;
@@ -99,6 +117,18 @@ export async function main(argv = process.argv.slice(2)) {
     case "doctor":
       await printDoctor();
       break;
+    case "migrate": {
+      const scan = await scanForMigration();
+      console.log(`Scanned ${scan.total} tools. Found ${scan.stale.length} with stale configs.`);
+      if (scan.stale.length > 0) {
+        const result = await migrateAllTools(options);
+        console.log(result.message);
+        result.results?.forEach((r) => {
+          console.log(`  ${r.ok ? "✓" : "✗"} ${r.tool}${r.ok ? "" : ` — ${r.error}`}`);
+        });
+      }
+      break;
+    }
     default:
       throw new Error(`Unknown command: ${command}. Run omega-plus --help.`);
   }

package/src/constants.mjs

@@ -1,9 +1,10 @@
-export const VERSION = "2.0.4";
+export const VERSION = "2.0.6";
 export const DEFAULT_ORIGIN = "https://omega.kesarcloud.in";
 export const DEFAULT_BASE_URL = `${DEFAULT_ORIGIN}/v1`;
 export const DEFAULT_ANTHROPIC_BASE_URL = `${DEFAULT_ORIGIN}/v1`;
 export const DEFAULT_OPENAI_BASE_URL = `${DEFAULT_ORIGIN}/api/v1`;
 export const DEFAULT_VALIDATION_URL = `${DEFAULT_ORIGIN}/api/omega/validate-key`;
+export const DOCS_URL = `${DEFAULT_ORIGIN}/documentation`;
 export const DEFAULT_MODEL = "omega-plus";
 export const DEFAULT_FAST_MODEL = "omega-plus";
 export const OMEGA_CONTEXT_WINDOW = 1_000_000;
@@ -11,6 +12,9 @@ export const OMEGA_MAX_OUTPUT_TOKENS = 32000;
 
 export const OMEGA_MODELS = [
   { id: "omega-plus", name: "Omega Plus" },
+  { id: "KesarCloud/anthropic/claude-opus-4-6", name: "Claude Opus 4.6" },
+  { id: "KesarCloud/anthropic/claude-opus-4.7", name: "Claude Opus 4.7" },
+  { id: "KesarCloud/openai/gpt-5.5", name: "GPT 5.5" },
 ];
 
 export const TOOL_IDS = ["claude", "codex", "opencode", "cline", "kilo", "droid"];

package/src/migrate.mjs

@@ -0,0 +1,95 @@
+import { detectAllTools } from "./detector.mjs";
+import { configureTool } from "./config-writers.mjs";
+import { DEFAULT_MODEL, DEFAULT_FAST_MODEL, VERSION } from "./constants.mjs";
+import { readJson, readText } from "./fs-utils.mjs";
+import { getToolPaths } from "./tool-paths.mjs";
+
+const OLD_MODEL_IDS = [/omega-v1(?![-]plus)/, /"Omega V1"/, /omega\.v1/i];
+const CURRENT_MODEL = "omega-plus";
+
+function hasOldModels(text) {
+  if (typeof text !== "string") return false;
+  return OLD_MODEL_IDS.some((re) => re.test(text));
+}
+
+async function detectStaleConfig(tool) {
+  if (tool.configStatus !== "configured" || !tool.configPath) return false;
+  try {
+    const content = await readText(tool.configPath, "");
+    return hasOldModels(content);
+  } catch {
+    return false;
+  }
+}
+
+async function detectAdditionalConfigs(tool) {
+  const paths = getToolPaths(tool.id);
+  const checks = [];
+  for (const [, p] of Object.entries(paths)) {
+    if (!p || p === tool.configPath) continue;
+    try {
+      const content = await readText(p, "");
+      if (hasOldModels(content) || hasOldModels(JSON.stringify(await readJson(p, null) || ""))) {
+        checks.push(p);
+      }
+    } catch {}
+  }
+  return checks;
+}
+
+export async function scanForMigration(options = {}) {
+  const tools = await detectAllTools();
+  const stale = [];
+
+  for (const tool of tools) {
+    if (await detectStaleConfig(tool)) {
+      const extra = await detectAdditionalConfigs(tool);
+      stale.push({ tool, paths: [tool.configPath, ...extra].filter(Boolean) });
+    }
+  }
+
+  return { stale, total: tools.length, version: VERSION };
+}
+
+export async function migrateAllTools(options = {}) {
+  const { stale } = await scanForMigration(options);
+  if (stale.length === 0) {
+    return { migrated: 0, message: "All configs are up to date with Omega Plus." };
+  }
+
+  const apiKey = options.apiKey || options.apikey;
+  if (!apiKey) {
+    return {
+      migrated: 0,
+      stale,
+      error: "API key required for migration. Use: npx @kesarcloud/omega-plus-cli --migrate --api-key YOUR_KEY",
+    };
+  }
+
+  const results = [];
+  for (const entry of stale) {
+    try {
+      const result = await configureTool(entry.tool.id, {
+        apiKey,
+        model: DEFAULT_MODEL,
+        fastModel: DEFAULT_FAST_MODEL,
+        ...options,
+      });
+      results.push({ tool: entry.tool.name, id: entry.tool.id, ok: true, files: result.files });
+    } catch (err) {
+      results.push({
+        tool: entry.tool.name,
+        id: entry.tool.id,
+        ok: false,
+        error: err.message || "Unknown error",
+      });
+    }
+  }
+
+  return {
+    migrated: results.filter((r) => r.ok).length,
+    total: stale.length,
+    results,
+    message: `Migrated ${results.filter((r) => r.ok).length}/${stale.length} tools to Omega Plus.`,
+  };
+}

package/src/wizard.mjs

@@ -2,6 +2,8 @@ import {
   DEFAULT_BASE_URL,
   DEFAULT_FAST_MODEL,
   DEFAULT_MODEL,
+  DEFAULT_ORIGIN,
+  DOCS_URL,
   TOOL_DEFINITIONS,
 } from "./constants.mjs";
 import { printBanner } from "./banner.mjs";
@@ -9,6 +11,22 @@ import { configureTool } from "./config-writers.mjs";
 import { detectAllTools, detectTool, runInstallCommand } from "./detector.mjs";
 import { validateApiKey } from "./key-validator.mjs";
 import { ask, askSecret, createPromptInterface } from "./prompts.mjs";
+import { scanForMigration, migrateAllTools } from "./migrate.mjs";
+import { configPath, roamingConfigPath, readJson } from "./fs-utils.mjs";
+import { fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+
+function openUrl(url) {
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") spawn("open", [url], { stdio: "ignore", detached: true }).unref();
+    else if (platform === "win32") spawn("start", ["", url], { stdio: "ignore", detached: true, shell: true }).unref();
+    else spawn("xdg-open", [url], { stdio: "ignore", detached: true }).unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 function printHeader() {
   printBanner();
@@ -57,21 +75,192 @@ async function maybeInstallTool(toolId, options, rl) {
   return detectTool(toolId);
 }
 
+export async function showMainMenu(rl, options = {}) {
+  const lines = [
+    "",
+    "  What would you like to do?",
+    "",
+    "    1. \u{1F680}  New Setup",
+    "       Connect a new tool with your API key",
+    "",
+    "    2. \u{1F504}  Update Current Setup",
+    "       Update existing tool configs with latest models",
+    "",
+    '    3. \u{1F4DA}  Documentation',
+    `       Open Omega Plus docs — ${DOCS_URL}`,
+    "",
+  ];
+  for (const line of lines) console.log(line);
+
+  if (options.update === true) return 2;
+  if (options.command === "docs") return 3;
+
+  const answer = await ask(rl, "  Enter option (1-3): ");
+  const num = Number.parseInt(answer.trim(), 10);
+  if (num === 1 || num === 2 || num === 3) return num;
+  return 0;
+}
+
+async function extractApiKeyFromConfig(toolId) {
+  const tool = TOOL_DEFINITIONS[toolId];
+  if (!tool) return null;
+
+  try {
+    switch (toolId) {
+      case "claude": {
+        const cfg = await readJson(configPath([".claude", "settings.json"]));
+        return cfg?.env?.ANTHROPIC_AUTH_TOKEN || null;
+      }
+      case "codex": {
+        const cfg = await readJson(configPath([".codex", "auth.json"]));
+        return cfg?.OPENAI_API_KEY || null;
+      }
+      case "opencode": {
+        const cfg = await readJson(configPath([".config", "opencode", "opencode.json"]));
+        return cfg?.provider?.kesarcloud?.options?.apiKey || cfg?.provider?.omega?.options?.apiKey || null;
+      }
+      case "cline": {
+        const cfg = await readJson(configPath([".cline", "data", "secrets.json"]));
+        return cfg?.anthropicApiKey || null;
+      }
+      case "kilo": {
+        const cfg = await readJson(roamingConfigPath(["kilo", "auth.json"]));
+        return cfg?.anthropic?.apiKey || null;
+      }
+      case "droid": {
+        const cfg = await readJson(configPath([".factory", "settings.json"]));
+        return cfg?.customModels?.[0]?.apiKey || null;
+      }
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+
+export async function runUpdateFlow(options = {}) {
+  const rl = createPromptInterface();
+  try {
+    const allTools = await detectAllTools();
+    const configured = allTools.filter((t) => t.configStatus === "configured" && t.installed);
+
+    if (configured.length === 0) {
+      console.log("\nNo configured tools found. Run New Setup first to connect a tool.\n");
+      return { skipped: true, reason: "no_configured_tools" };
+    }
+
+    console.log("\nSelect a tool to update:");
+    configured.forEach((tool, index) => {
+      console.log(`  ${index + 1}. ${tool.name}`);
+    });
+
+    const answer = options.tool || (await ask(rl, "\nEnter tool number: "));
+    const trimmed = String(answer || "").trim();
+    let toolId = null;
+    if (TOOL_DEFINITIONS[trimmed.toLowerCase()]) {
+      toolId = trimmed.toLowerCase();
+    } else {
+      const num = Number.parseInt(trimmed, 10);
+      if (num >= 1 && num <= configured.length) toolId = configured[num - 1].id;
+    }
+    if (!toolId) throw new Error("Invalid tool selection");
+
+    // Extract API key from existing config
+    let apiKey = await extractApiKeyFromConfig(toolId);
+    if (!apiKey) {
+      console.log("\nCould not read your existing API key from config.");
+      apiKey = await askSecret("Paste your Omega API key to continue: ");
+      if (!apiKey) throw new Error("API key is required");
+    } else {
+      console.log(`\nUsing existing API key from ${toolId} config...`);
+    }
+
+    console.log("\nUpdating configuration with latest models...");
+    const result = await configureTool(toolId, {
+      apiKey,
+      baseUrl: options.baseUrl || DEFAULT_BASE_URL,
+      openaiBaseUrl: options.openaiBaseUrl,
+      anthropicBaseUrl: options.anthropicBaseUrl,
+      model: options.model || DEFAULT_MODEL,
+      fastModel: options.fastModel || DEFAULT_FAST_MODEL,
+      dryRun: options.dryRun,
+    });
+
+    if (options.dryRun) {
+      console.log("\nDry run complete. No files were changed.");
+      result.files.forEach((file) => console.log(`  would write: ${file.path}`));
+      return result;
+    }
+
+    console.log(`\n${result.message}`);
+    result.files.forEach((file) => {
+      console.log(`  updated: ${file.path}`);
+    });
+    console.log("\nYour models have been updated to the latest Omega Plus endpoints.");
+    return result;
+  } finally {
+    rl.close();
+  }
+}
+
 export async function runWizard(options = {}) {
   printHeader();
-  const apiKey = options.apiKey || (await askSecret("Paste your Omega API key: "));
-  if (!apiKey) throw new Error("API key is required");
 
-  console.log("Checking your Omega API key...");
-  await validateApiKey(apiKey, {
-    baseUrl: options.baseUrl || DEFAULT_BASE_URL,
-    validationUrl: options.validationUrl,
-    skipKeyValidation: options.skipKeyValidation,
-  });
-  console.log(options.skipKeyValidation ? "API key validation skipped." : "API key verified.");
+  // ── Check for stale configs (old omega-v1/v1-pro model IDs) ──
+  if (!options.skipMigrationCheck) {
+    const migration = await scanForMigration();
+    if (migration.stale.length > 0) {
+      console.log(`\nDetected ${migration.stale.length} tool(s) with old model configs (omega-v1 / omega-v1-pro).`);
+      console.log("These should be migrated to Omega Plus.\n");
+      if (options.yes || options.migrateAll) {
+        console.log("Auto-migrating...");
+        const result = await migrateAllTools({ ...options, apiKey: options.apiKey });
+        console.log(result.message);
+        result.results?.forEach((r) => {
+          console.log(`  ${r.ok ? "✓" : "✗"} ${r.tool}${r.ok ? "" : ` — ${r.error}`}`);
+        });
+        console.log("");
+      } else {
+        console.log("Tip: re-run with --migrate-all to auto-update, or continue to reconfigure manually.\n");
+      }
+    }
+  }
 
   const rl = createPromptInterface();
   try {
+    // ── Show main menu ──
+    const menuChoice = await showMainMenu(rl, options);
+
+    // Option 3: Docs
+    if (menuChoice === 3) {
+      console.log(`\nOpening ${DOCS_URL} ...`);
+      const opened = openUrl(DOCS_URL);
+      if (!opened) console.log(`Please visit: ${DOCS_URL}`);
+      return { skipped: true, reason: "docs" };
+    }
+
+    // Option 2: Update
+    if (menuChoice === 2) {
+      return runUpdateFlow(options);
+    }
+
+    // Option 1 or invalid: New Setup (default)
+    if (menuChoice !== 1 && menuChoice !== 0) {
+      console.log("\nStarting New Setup...\n");
+    }
+
+    const apiKey = options.apiKey || (await askSecret("Paste your Omega API key: "));
+    if (!apiKey) throw new Error("API key is required");
+
+    console.log("Checking your Omega API key...");
+    await validateApiKey(apiKey, {
+      baseUrl: options.baseUrl || DEFAULT_BASE_URL,
+      validationUrl: options.validationUrl,
+      skipKeyValidation: options.skipKeyValidation,
+    });
+    console.log(options.skipKeyValidation ? "API key validation skipped." : "API key verified.");
+
     const tools = await detectAllTools();
     printTools(tools);
     const answer = options.tool || (await ask(rl, "\nEnter tool number: "));