@kesarcloud/omega-plus-cli 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 KesarCloud Technologies
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,38 @@
+# Omega Plus CLI
+
+Interactive setup wizard for connecting local coding tools to Omega Plus.
+
+```bash
+npx @kesarcloud/omega-plus-cli
+```
+
+The wizard shows the Omega Plus banner, validates your Omega API key, lets you choose a supported coding tool, backs up existing config files, and writes Omega Plus settings.
+
+## Supported Tools
+
+- Claude Code
+- OpenAI Codex CLI
+- OpenCode
+- Cline
+- Kilo Code
+- Factory Droid
+
+## Non-Interactive Usage
+
+```bash
+npx @kesarcloud/omega-plus-cli configure --tool claude --api-key YOUR_KEY
+npx @kesarcloud/omega-plus-cli configure --tool codex --api-key YOUR_KEY --dry-run
+```
+
+Defaults:
+
+- Base URL: `https://omega.kesarcloud.in/v1`
+- 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`
+
+Use `--base-url`, `--openai-base-url`, `--anthropic-base-url`, `--model`, or `--fast-model` to override them.
+
+Codex receives the OpenAI-compatible endpoint. Claude Code, OpenCode, Cline, Kilo Code, and Factory Droid receive the Anthropic-compatible endpoint. The CLI validates the key before writing configs; use `--skip-key-validation` only for local testing or dry runs against an unavailable server.

package/bin/omega-plus.mjs

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { main } from "../src/cli.mjs";
+
+main(process.argv.slice(2)).catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Omega Plus setup failed: ${message}`);
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@kesarcloud/omega-plus-cli",
+  "version": "2.0.0",
+  "description": "Interactive Omega Plus setup wizard for coding CLI tools.",
+  "type": "module",
+  "bin": {
+    "omega": "bin/omega-plus.mjs",
+    "omega-plus": "bin/omega-plus.mjs"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "omega-plus",
+    "omega-v1",
+    "claude-code",
+    "codex",
+    "opencode",
+    "cline",
+    "kilocode",
+    "factory-droid",
+    "ai-cli"
+  ],
+  "license": "MIT",
+  "author": "KesarCloud Technologies",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/karanbavari/OmegaCluster",
+    "directory": "packages/omega-cli-helper"
+  },
+  "scripts": {
+    "test": "node --test ../../tests/unit/omega-cli-helper.test.mjs"
+  }
+}

package/src/banner.mjs

@@ -0,0 +1,20 @@
+const RED = "\x1b[38;5;196m";
+const ORANGE = "\x1b[38;5;208m";
+const YELLOW = "\x1b[38;5;214m";
+const RESET = "\x1b[0m";
+const BOLD = "\x1b[1m";
+
+export function getBanner() {
+  return [
+    `${BOLD}${RED}   ____  __  __ _____ ____    _    ${ORANGE}   ____  _    _   _ ____ ${RESET}`,
+    `${BOLD}${RED}  / __ \\|  \\/  | ____/ ___|  / \\   ${ORANGE}  |  _ \\| |  | | | / ___|${RESET}`,
+    `${BOLD}${ORANGE} | |  | | |\\/| |  _|| |  _  / _ \\  ${YELLOW}  | |_) | |  | | | \\___ \\${RESET}`,
+    `${BOLD}${ORANGE} | |__| | |  | | |__| |_| |/ ___ \\ ${YELLOW}  |  __/| |__| |_| |___) |${RESET}`,
+    `${BOLD}${YELLOW}  \\____/|_|  |_|_____\\____/_/   \\_\\${RED}  |_|   |_____\\___/|____/${RESET}`,
+  ].join("\n");
+}
+
+export function printBanner() {
+  console.log(`\n${getBanner()}`);
+  console.log(`${ORANGE}Connect your coding tool to Omega V1.${RESET}\n`);
+}

package/src/cli.mjs

@@ -0,0 +1,105 @@
+import {
+  DEFAULT_ANTHROPIC_BASE_URL,
+  DEFAULT_BASE_URL,
+  DEFAULT_FAST_MODEL,
+  DEFAULT_MODEL,
+  DEFAULT_OPENAI_BASE_URL,
+  DEFAULT_VALIDATION_URL,
+  VERSION,
+} from "./constants.mjs";
+import { printDoctor, printToolList, runNonInteractiveConfigure, runWizard } from "./wizard.mjs";
+
+function printHelp() {
+  console.log(`Omega Plus CLI ${VERSION}
+
+Usage:
+  omega-plus
+  omega-plus setup
+  omega-plus configure --tool <id> --api-key <key>
+  omega-plus list
+  omega-plus doctor
+
+Options:
+  --api-key <key>       Omega API key
+  --tool <id>           claude, codex, opencode, cline, kilo, droid
+  --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}
+  --validation-url      Default: ${DEFAULT_VALIDATION_URL}
+  --model <id>          Default: ${DEFAULT_MODEL}
+  --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
+  --no-install          Do not install missing tools
+  --help                Show help
+  --version             Show version
+`);
+}
+
+function parseArgs(argv) {
+  const args = [...argv];
+  const options = {};
+  const positionals = [];
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--help" || arg === "-h") options.help = true;
+    else if (arg === "--version" || arg === "-v") options.version = true;
+    else if (arg === "--dry-run") options.dryRun = true;
+    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 === "--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];
+    else if (arg.startsWith("--tool=")) options.tool = arg.slice("--tool=".length);
+    else if (arg === "--base-url") options.baseUrl = args[++i];
+    else if (arg.startsWith("--base-url=")) options.baseUrl = arg.slice("--base-url=".length);
+    else if (arg === "--openai-base-url") options.openaiBaseUrl = args[++i];
+    else if (arg.startsWith("--openai-base-url="))
+      options.openaiBaseUrl = arg.slice("--openai-base-url=".length);
+    else if (arg === "--anthropic-base-url") options.anthropicBaseUrl = args[++i];
+    else if (arg.startsWith("--anthropic-base-url="))
+      options.anthropicBaseUrl = arg.slice("--anthropic-base-url=".length);
+    else if (arg === "--validation-url") options.validationUrl = args[++i];
+    else if (arg.startsWith("--validation-url="))
+      options.validationUrl = arg.slice("--validation-url=".length);
+    else if (arg === "--model") options.model = args[++i];
+    else if (arg.startsWith("--model=")) options.model = arg.slice("--model=".length);
+    else if (arg === "--fast-model") options.fastModel = args[++i];
+    else if (arg.startsWith("--fast-model=")) options.fastModel = arg.slice("--fast-model=".length);
+    else positionals.push(arg);
+  }
+
+  return { command: positionals[0] || "setup", options };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const { command, options } = parseArgs(argv);
+  if (options.help) {
+    printHelp();
+    return;
+  }
+  if (options.version) {
+    console.log(VERSION);
+    return;
+  }
+
+  switch (command) {
+    case "setup":
+      await runWizard(options);
+      break;
+    case "configure":
+      await runNonInteractiveConfigure(options);
+      break;
+    case "list":
+      await printToolList();
+      break;
+    case "doctor":
+      await printDoctor();
+      break;
+    default:
+      throw new Error(`Unknown command: ${command}. Run omega-plus --help.`);
+  }
+}

package/src/config-writers.mjs

@@ -0,0 +1,247 @@
+import {
+  DEFAULT_BASE_URL,
+  TOOL_DEFINITIONS,
+  DEFAULT_FAST_MODEL,
+  DEFAULT_MODEL,
+  OMEGA_MODELS,
+} from "./constants.mjs";
+import {
+  deriveEndpointOptions,
+  normalizeCodexBaseUrl,
+  normalizeHttpBaseUrl,
+  readJson,
+  readText,
+  writeJsonFile,
+  writeTextFile,
+} from "./fs-utils.mjs";
+import { getToolPaths } from "./tool-paths.mjs";
+import { parseToml, stringifyToml } from "./toml.mjs";
+
+function resolveOptions(input = {}) {
+  const baseUrl = input.baseUrl || DEFAULT_BASE_URL;
+  const endpoints = deriveEndpointOptions({
+    baseUrl,
+    anthropicBaseUrl: input.anthropicBaseUrl,
+    openaiBaseUrl: input.openaiBaseUrl,
+  });
+  return {
+    baseUrl: normalizeHttpBaseUrl(baseUrl),
+    anthropicBaseUrl: endpoints.anthropicBaseUrl,
+    openaiBaseUrl: endpoints.openaiBaseUrl,
+    apiKey: String(input.apiKey || "").trim(),
+    model: String(input.model || DEFAULT_MODEL).trim(),
+    fastModel: String(input.fastModel || DEFAULT_FAST_MODEL).trim(),
+    dryRun: Boolean(input.dryRun),
+    home: input.home,
+    appData: input.appData,
+  };
+}
+
+function requireApiKey(apiKey) {
+  if (!apiKey) throw new Error("API key is required");
+}
+
+function modelEntries(model, fastModel) {
+  return [...new Set([model, fastModel, ...OMEGA_MODELS.map((entry) => entry.id)].filter(Boolean))];
+}
+
+async function configureClaude(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("claude", options);
+  const settings = await readJson(paths.settings, {});
+  const env =
+    settings && typeof settings.env === "object" && !Array.isArray(settings.env)
+      ? settings.env
+      : {};
+
+  const nextSettings = {
+    ...settings,
+    env: {
+      ...env,
+      ANTHROPIC_AUTH_TOKEN: options.apiKey,
+      ANTHROPIC_BASE_URL: options.anthropicBaseUrl,
+      ANTHROPIC_MODEL: options.model,
+      ANTHROPIC_SMALL_FAST_MODEL: options.fastModel,
+      CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+    },
+    hasCompletedOnboarding: true,
+  };
+
+  const write = await writeJsonFile(paths.settings, nextSettings, options);
+  return { toolId: "claude", files: [write], message: "Claude Code is configured for Omega Plus." };
+}
+
+async function configureCodex(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("codex", options);
+  const parsed = parseToml(await readText(paths.config, ""));
+
+  parsed._root.model = options.model;
+  parsed._root.model_provider = "omega";
+  delete parsed._root.openai_base_url;
+  parsed._sections["model_providers.omega"] = {
+    name: "Omega Plus",
+    base_url: normalizeCodexBaseUrl(options.openaiBaseUrl),
+    wire_api: "chat",
+    env_key: "OPENAI_API_KEY",
+  };
+  delete parsed._sections["model_providers.omniroute"];
+
+  const configWrite = await writeTextFile(paths.config, stringifyToml(parsed), options);
+  const auth = await readJson(paths.auth, {});
+  auth.OPENAI_API_KEY = options.apiKey;
+  const authWrite = await writeJsonFile(paths.auth, auth, options);
+
+  return {
+    toolId: "codex",
+    files: [configWrite, authWrite],
+    message: "OpenAI Codex CLI is configured for Omega Plus.",
+  };
+}
+
+function buildOpenCodeProvider(options) {
+  const models = {};
+  for (const model of modelEntries(options.model, options.fastModel)) {
+    const label = OMEGA_MODELS.find((entry) => entry.id === model)?.name || model;
+    models[model] = { name: label };
+  }
+
+  return {
+    npm: "@ai-sdk/anthropic",
+    name: "Omega Plus",
+    options: {
+      baseURL: options.anthropicBaseUrl,
+      apiKey: options.apiKey,
+    },
+    models,
+  };
+}
+
+async function configureOpenCode(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("opencode", options);
+  const current = await readJson(paths.config, {});
+  const provider =
+    current && typeof current.provider === "object" && !Array.isArray(current.provider)
+      ? current.provider
+      : {};
+
+  const nextConfig = {
+    ...current,
+    $schema: current.$schema || "https://opencode.ai/config.json",
+    provider: {
+      ...provider,
+      omega: buildOpenCodeProvider(options),
+    },
+  };
+  if (nextConfig.provider.omniroute) delete nextConfig.provider.omniroute;
+
+  const write = await writeJsonFile(paths.config, nextConfig, options);
+  return { toolId: "opencode", files: [write], message: "OpenCode is configured for Omega Plus." };
+}
+
+async function configureCline(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("cline", options);
+  const globalState = await readJson(paths.globalState, {});
+
+  const nextState = {
+    ...globalState,
+    actModeApiProvider: "anthropic",
+    planModeApiProvider: "anthropic",
+    anthropicBaseUrl: options.anthropicBaseUrl,
+    anthropicModelId: options.model,
+    planModeAnthropicModelId: options.model,
+  };
+
+  const secrets = await readJson(paths.secrets, {});
+  secrets.anthropicApiKey = options.apiKey;
+
+  const stateWrite = await writeJsonFile(paths.globalState, nextState, options);
+  const secretsWrite = await writeJsonFile(paths.secrets, secrets, options);
+  return {
+    toolId: "cline",
+    files: [stateWrite, secretsWrite],
+    message: "Cline is configured for Omega Plus.",
+  };
+}
+
+async function configureKilo(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("kilo", options);
+  const auth = await readJson(paths.auth, {});
+
+  auth.anthropic = {
+    type: "api-key",
+    apiKey: options.apiKey,
+    baseUrl: options.anthropicBaseUrl,
+    model: options.model,
+  };
+
+  const writes = [await writeJsonFile(paths.auth, auth, options)];
+
+  const vscodeSettings = await readJson(paths.vscodeSettings, null);
+  if (vscodeSettings && typeof vscodeSettings === "object" && !Array.isArray(vscodeSettings)) {
+    vscodeSettings["kilocode.customProvider"] = {
+      name: "Omega Plus",
+      baseURL: options.anthropicBaseUrl,
+      apiKey: options.apiKey,
+    };
+    vscodeSettings["kilocode.defaultModel"] = options.model;
+    writes.push(await writeJsonFile(paths.vscodeSettings, vscodeSettings, options));
+  }
+
+  return { toolId: "kilo", files: writes, message: "Kilo Code is configured for Omega Plus." };
+}
+
+async function configureDroid(input) {
+  const options = resolveOptions(input);
+  requireApiKey(options.apiKey);
+  const paths = getToolPaths("droid", options);
+  const settings = await readJson(paths.settings, {});
+  const existingModels = Array.isArray(settings.customModels) ? settings.customModels : [];
+
+  settings.customModels = existingModels.filter(
+    (entry) => entry?.id !== "custom:OmegaPlus-0" && entry?.id !== "custom:OmniRoute-0"
+  );
+  settings.customModels.unshift({
+    model: options.model,
+    id: "custom:OmegaPlus-0",
+    index: 0,
+    baseUrl: options.anthropicBaseUrl,
+    apiKey: options.apiKey,
+    displayName: "Omega V1 Pro",
+    maxOutputTokens: 131072,
+    noImageSupport: false,
+    provider: "anthropic",
+  });
+
+  const write = await writeJsonFile(paths.settings, settings, options);
+  return {
+    toolId: "droid",
+    files: [write],
+    message: "Factory Droid is configured for Omega Plus.",
+  };
+}
+
+export const CONFIG_WRITERS = {
+  claude: configureClaude,
+  codex: configureCodex,
+  opencode: configureOpenCode,
+  cline: configureCline,
+  kilo: configureKilo,
+  droid: configureDroid,
+};
+
+export async function configureTool(toolId, input = {}) {
+  const id = String(toolId || "")
+    .trim()
+    .toLowerCase();
+  if (!TOOL_DEFINITIONS[id]) throw new Error(`Unsupported tool: ${toolId}`);
+  return CONFIG_WRITERS[id](input);
+}

package/src/constants.mjs

@@ -0,0 +1,60 @@
+export const VERSION = "2.0.0";
+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 DEFAULT_MODEL = "omega-v1-pro";
+export const DEFAULT_FAST_MODEL = "omega-v1";
+
+export const OMEGA_MODELS = [
+  { id: "omega-v1-pro", name: "Omega V1 Pro" },
+  { id: "omega-v1", name: "Omega V1" },
+];
+
+export const TOOL_IDS = ["claude", "codex", "opencode", "cline", "kilo", "droid"];
+
+export const TOOL_DEFINITIONS = {
+  claude: {
+    id: "claude",
+    name: "Claude Code",
+    commands: ["claude"],
+    installCommand: ["npm", ["install", "-g", "@anthropic-ai/claude-code"]],
+    installHint: "npm install -g @anthropic-ai/claude-code",
+  },
+  codex: {
+    id: "codex",
+    name: "OpenAI Codex CLI",
+    commands: ["codex"],
+    installCommand: ["npm", ["install", "-g", "@openai/codex"]],
+    installHint: "npm install -g @openai/codex",
+  },
+  opencode: {
+    id: "opencode",
+    name: "OpenCode",
+    commands: ["opencode"],
+    installCommand: ["npm", ["install", "-g", "opencode-ai"]],
+    installHint: "npm install -g opencode-ai",
+  },
+  cline: {
+    id: "cline",
+    name: "Cline",
+    commands: ["cline"],
+    installCommand: null,
+    installHint: "Install Cline first, then rerun this wizard.",
+  },
+  kilo: {
+    id: "kilo",
+    name: "Kilo Code",
+    commands: ["kilocode", "kilo"],
+    installCommand: ["npm", ["install", "-g", "@kilocode/cli"]],
+    installHint: "npm install -g @kilocode/cli",
+  },
+  droid: {
+    id: "droid",
+    name: "Factory Droid",
+    commands: ["droid"],
+    installCommand: ["sh", ["-c", "curl -fsSL https://app.factory.ai/cli | sh"]],
+    installHint: "curl -fsSL https://app.factory.ai/cli | sh",
+  },
+};

package/src/detector.mjs

@@ -0,0 +1,132 @@
+import { execFile, spawn } from "node:child_process";
+import { promisify } from "node:util";
+import { TOOL_DEFINITIONS, TOOL_IDS } from "./constants.mjs";
+import { fileExists, readJson, readText } from "./fs-utils.mjs";
+import { getToolPaths } from "./tool-paths.mjs";
+
+const execFileAsync = promisify(execFile);
+
+export async function commandExists(command) {
+  try {
+    if (process.platform === "win32") {
+      const { stdout } = await execFileAsync("where.exe", [command], { timeout: 3000 });
+      return Boolean(stdout.trim());
+    }
+    const { stdout } = await execFileAsync("sh", ["-c", 'command -v -- "$1"', "sh", command], {
+      timeout: 3000,
+    });
+    return Boolean(stdout.trim());
+  } catch {
+    return false;
+  }
+}
+
+async function getVersion(command) {
+  try {
+    const { stdout, stderr } = await execFileAsync(command, ["--version"], { timeout: 5000 });
+    return (
+      String(stdout || stderr || "")
+        .trim()
+        .replace(/^v/, "") || null
+    );
+  } catch {
+    return null;
+  }
+}
+
+async function detectCommand(commands) {
+  for (const command of commands || []) {
+    if (await commandExists(command)) {
+      return { installed: true, command, version: await getVersion(command) };
+    }
+  }
+  return { installed: false, command: commands?.[0] || null, version: null };
+}
+
+async function configStatus(toolId, options = {}) {
+  const paths = getToolPaths(toolId, options);
+  try {
+    if (toolId === "claude") {
+      const settings = await readJson(paths.settings, null);
+      return settings?.env?.ANTHROPIC_BASE_URL && settings?.env?.ANTHROPIC_AUTH_TOKEN
+        ? "configured"
+        : "not_configured";
+    }
+    if (toolId === "codex") {
+      const config = await readText(paths.config, "");
+      const auth = await readJson(paths.auth, {});
+      return config.includes("[model_providers.omega]") && auth.OPENAI_API_KEY
+        ? "configured"
+        : "not_configured";
+    }
+    if (toolId === "opencode") {
+      const config = await readJson(paths.config, null);
+      return config?.provider?.omega?.options?.apiKey ? "configured" : "not_configured";
+    }
+    if (toolId === "cline") {
+      const state = await readJson(paths.globalState, null);
+      const secrets = await readJson(paths.secrets, {});
+      return state?.actModeApiProvider === "anthropic" &&
+        state?.anthropicBaseUrl &&
+        secrets.anthropicApiKey
+        ? "configured"
+        : "not_configured";
+    }
+    if (toolId === "kilo") {
+      const auth = await readJson(paths.auth, null);
+      return auth?.anthropic?.apiKey ? "configured" : "not_configured";
+    }
+    if (toolId === "droid") {
+      const settings = await readJson(paths.settings, null);
+      const models = Array.isArray(settings?.customModels) ? settings.customModels : [];
+      return models.some(
+        (entry) => entry?.id === "custom:OmegaPlus-0" && entry?.provider === "anthropic"
+      )
+        ? "configured"
+        : "not_configured";
+    }
+  } catch {
+    return "not_configured";
+  }
+  return "unknown";
+}
+
+export async function detectTool(toolId, options = {}) {
+  const definition = TOOL_DEFINITIONS[toolId];
+  if (!definition) return null;
+  const command = await detectCommand(definition.commands);
+  const paths = getToolPaths(toolId, options);
+  const primaryPath = Object.values(paths)[0] || null;
+  return {
+    id: definition.id,
+    name: definition.name,
+    installed: command.installed,
+    command: command.command,
+    version: command.version,
+    configPath: primaryPath,
+    configExists: primaryPath ? await fileExists(primaryPath) : false,
+    configStatus: await configStatus(toolId, options),
+    installHint: definition.installHint,
+    canAutoInstall: Boolean(definition.installCommand),
+  };
+}
+
+export async function detectAllTools(options = {}) {
+  return Promise.all(TOOL_IDS.map((id) => detectTool(id, options)));
+}
+
+export function runInstallCommand(toolId) {
+  const definition = TOOL_DEFINITIONS[toolId];
+  if (!definition?.installCommand) {
+    throw new Error(`No automatic installer is configured for ${definition?.name || toolId}`);
+  }
+  const [command, args] = definition.installCommand;
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: "inherit", shell: false });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0) resolve();
+      else reject(new Error(`${definition.name} installer exited with code ${code}`));
+    });
+  });
+}

package/src/fs-utils.mjs

@@ -0,0 +1,126 @@
+import fs from "node:fs/promises";
+import fsSync from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export function getHome(options = {}) {
+  return options.home || process.env.HOME || process.env.USERPROFILE || os.homedir();
+}
+
+export function getAppData(options = {}) {
+  return (
+    options.appData || process.env.APPDATA || path.join(getHome(options), "AppData", "Roaming")
+  );
+}
+
+export function configPath(parts, options = {}) {
+  return path.join(getHome(options), ...parts);
+}
+
+export function roamingConfigPath(parts, options = {}) {
+  if (process.platform === "win32") return path.join(getAppData(options), ...parts);
+  return path.join(getHome(options), ".config", ...parts);
+}
+
+export function normalizeHttpBaseUrl(value, { ensureV1 = true } = {}) {
+  const raw = String(value || "")
+    .trim()
+    .replace(/\/+$/, "");
+  if (!raw) throw new Error("Base URL is required");
+  const url = new URL(raw);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Base URL must start with http:// or https://");
+  }
+  if (!ensureV1) return raw;
+  return raw.endsWith("/v1") ? raw : `${raw}/v1`;
+}
+
+export function normalizeOpenAiBaseUrl(value) {
+  const base = normalizeHttpBaseUrl(value, { ensureV1: false })
+    .replace(/\/v1\/?$/, "")
+    .replace(/\/api\/?$/, "");
+  return `${base}/api/v1`;
+}
+
+export const normalizeCodexBaseUrl = normalizeOpenAiBaseUrl;
+
+export function normalizeAnthropicBaseUrl(value) {
+  const raw = normalizeHttpBaseUrl(value, { ensureV1: false })
+    .replace(/\/api\/v1\/?$/, "")
+    .replace(/\/api\/?$/, "");
+  return raw.endsWith("/v1") ? raw : `${raw}/v1`;
+}
+
+export function deriveEndpointOptions(input = {}) {
+  const originBase = input.baseUrl
+    ? normalizeHttpBaseUrl(input.baseUrl, { ensureV1: false })
+        .replace(/\/api\/v1\/?$/, "")
+        .replace(/\/v1\/?$/, "")
+        .replace(/\/api\/?$/, "")
+    : null;
+
+  return {
+    anthropicBaseUrl: normalizeAnthropicBaseUrl(
+      input.anthropicBaseUrl || (originBase ? `${originBase}/v1` : undefined) || input.baseUrl
+    ),
+    openaiBaseUrl: normalizeOpenAiBaseUrl(
+      input.openaiBaseUrl || (originBase ? `${originBase}/api/v1` : undefined) || input.baseUrl
+    ),
+  };
+}
+
+export function stripV1(value) {
+  return normalizeHttpBaseUrl(value).replace(/\/v1\/?$/, "");
+}
+
+export async function readJson(filePath, fallback = {}) {
+  try {
+    return JSON.parse(await fs.readFile(filePath, "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return fallback;
+    return fallback;
+  }
+}
+
+export async function readText(filePath, fallback = "") {
+  try {
+    return await fs.readFile(filePath, "utf8");
+  } catch (error) {
+    if (error?.code === "ENOENT") return fallback;
+    return fallback;
+  }
+}
+
+export async function fileExists(filePath) {
+  try {
+    await fs.access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function backupFile(filePath, label = "omega-plus") {
+  if (!fsSync.existsSync(filePath)) return null;
+  const dir = path.dirname(filePath);
+  const backupDir = path.join(dir, ".omega-plus.bak");
+  await fs.mkdir(backupDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupPath = path.join(backupDir, `${path.basename(filePath)}.${stamp}.${label}.bak`);
+  await fs.copyFile(filePath, backupPath);
+  return backupPath;
+}
+
+export async function writeTextFile(filePath, content, options = {}) {
+  if (options.dryRun) {
+    return { path: filePath, backupPath: null, dryRun: true, content };
+  }
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  const backupPath = await backupFile(filePath);
+  await fs.writeFile(filePath, content, "utf8");
+  return { path: filePath, backupPath, dryRun: false };
+}
+
+export async function writeJsonFile(filePath, value, options = {}) {
+  return writeTextFile(filePath, `${JSON.stringify(value, null, 2)}\n`, options);
+}

package/src/key-validator.mjs

@@ -0,0 +1,72 @@
+import { DEFAULT_VALIDATION_URL } from "./constants.mjs";
+
+export class ApiKeyValidationError extends Error {
+  constructor(message, status = "invalid") {
+    super(message);
+    this.name = "ApiKeyValidationError";
+    this.status = status;
+  }
+}
+
+export function resolveValidationUrl(options = {}) {
+  if (options.validationUrl) return String(options.validationUrl).trim();
+  const base = String(options.baseUrl || "")
+    .trim()
+    .replace(/\/+$/, "");
+  if (!base) return DEFAULT_VALIDATION_URL;
+  const origin = base
+    .replace(/\/api\/v1\/?$/, "")
+    .replace(/\/v1\/?$/, "")
+    .replace(/\/api\/?$/, "");
+  return `${origin}/api/omega/validate-key`;
+}
+
+export async function validateApiKey(apiKey, options = {}) {
+  const trimmed = String(apiKey || "").trim();
+  if (!trimmed) {
+    throw new ApiKeyValidationError("API key is required", "invalid");
+  }
+
+  if (options.skipKeyValidation) {
+    return { valid: true, status: "skipped", message: "API key validation skipped" };
+  }
+
+  const url = resolveValidationUrl(options);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${trimmed}`,
+      },
+      body: JSON.stringify({ apiKey: trimmed }),
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new ApiKeyValidationError(
+      `Could not reach Omega validation server: ${message}`,
+      "unreachable"
+    );
+  }
+
+  let body = {};
+  try {
+    body = await response.json();
+  } catch {
+    body = {};
+  }
+
+  if (response.ok && body?.valid === true) {
+    return body;
+  }
+
+  const status = body?.status === "expired" ? "expired" : "invalid";
+  const message =
+    typeof body?.message === "string" && body.message.trim()
+      ? body.message.trim()
+      : status === "expired"
+        ? "API key expired"
+        : "Invalid API key";
+  throw new ApiKeyValidationError(message, status);
+}

package/src/prompts.mjs

@@ -0,0 +1,61 @@
+import readline from "node:readline";
+
+export function createPromptInterface() {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+export function ask(rl, question) {
+  return new Promise((resolve) => rl.question(question, (answer) => resolve(answer.trim())));
+}
+
+export async function askSecret(question) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    const rl = createPromptInterface();
+    try {
+      return await ask(rl, question);
+    } finally {
+      rl.close();
+    }
+  }
+
+  process.stdout.write(question);
+  readline.emitKeypressEvents(process.stdin);
+  const wasRaw = process.stdin.isRaw;
+  process.stdin.setRawMode(true);
+
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const cleanup = () => {
+      process.stdin.off("keypress", onKeypress);
+      process.stdin.setRawMode(wasRaw);
+      process.stdout.write("\n");
+    };
+    const onKeypress = (str, key) => {
+      if (key?.ctrl && key?.name === "c") {
+        cleanup();
+        reject(new Error("Cancelled"));
+        return;
+      }
+      if (key?.name === "return" || key?.name === "enter") {
+        cleanup();
+        resolve(value.trim());
+        return;
+      }
+      if (key?.name === "backspace") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          process.stdout.write("\b \b");
+        }
+        return;
+      }
+      if (str && !key?.ctrl && !key?.meta) {
+        value += str;
+        process.stdout.write("*");
+      }
+    };
+    process.stdin.on("keypress", onKeypress);
+  });
+}

package/src/toml.mjs

@@ -0,0 +1,69 @@
+export function parseToml(content) {
+  const result = { _root: {}, _sections: {} };
+  let currentSection = "_root";
+
+  for (const line of String(content || "").split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const sectionMatch = trimmed.match(/^\[(.+)]$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      if (!result._sections[currentSection]) result._sections[currentSection] = {};
+      continue;
+    }
+
+    const kvMatch = trimmed.match(/^([^=]+)\s*=\s*(.+)$/);
+    if (!kvMatch) continue;
+
+    let key = kvMatch[1].trim();
+    if ((key.startsWith('"') && key.endsWith('"')) || (key.startsWith("'") && key.endsWith("'"))) {
+      key = key.slice(1, -1);
+    }
+
+    const parsedValue = parseTomlValue(kvMatch[2].trim());
+    if (currentSection === "_root") result._root[key] = parsedValue;
+    else result._sections[currentSection][key] = parsedValue;
+  }
+
+  return result;
+}
+
+function parseTomlValue(rawValue) {
+  if (rawValue === "true") return true;
+  if (rawValue === "false") return false;
+  if (
+    (rawValue.startsWith('"') && rawValue.endsWith('"')) ||
+    (rawValue.startsWith("'") && rawValue.endsWith("'"))
+  ) {
+    return rawValue.slice(1, -1);
+  }
+  if (/^-?\d+$/.test(rawValue)) return Number.parseInt(rawValue, 10);
+  if (/^-?\d+\.\d+$/.test(rawValue)) return Number.parseFloat(rawValue);
+  return rawValue;
+}
+
+function formatTomlValue(value) {
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") return String(value);
+  if (typeof value === "string" && value.startsWith("[") && value.endsWith("]")) return value;
+  return JSON.stringify(String(value ?? ""));
+}
+
+export function stringifyToml(parsed) {
+  const lines = [];
+  for (const [key, value] of Object.entries(parsed._root || {})) {
+    lines.push(`${key} = ${formatTomlValue(value)}`);
+  }
+
+  for (const [section, values] of Object.entries(parsed._sections || {})) {
+    lines.push("");
+    lines.push(`[${section}]`);
+    for (const [key, value] of Object.entries(values || {})) {
+      const formattedKey = key.includes(".") ? JSON.stringify(key) : key;
+      lines.push(`${formattedKey} = ${formatTomlValue(value)}`);
+    }
+  }
+
+  return `${lines.join("\n")}\n`;
+}

package/src/tool-paths.mjs

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { configPath, getAppData, roamingConfigPath } from "./fs-utils.mjs";
+
+export function getToolPaths(toolId, options = {}) {
+  switch (toolId) {
+    case "claude":
+      return {
+        settings: configPath([".claude", "settings.json"], options),
+      };
+    case "codex":
+      return {
+        config: configPath([".codex", "config.toml"], options),
+        auth: configPath([".codex", "auth.json"], options),
+      };
+    case "opencode":
+      return {
+        config:
+          process.platform === "win32"
+            ? path.join(getAppData(options), "opencode", "opencode.json")
+            : roamingConfigPath(["opencode", "opencode.json"], options),
+      };
+    case "cline":
+      return {
+        globalState: configPath([".cline", "data", "globalState.json"], options),
+        secrets: configPath([".cline", "data", "secrets.json"], options),
+      };
+    case "kilo":
+      return {
+        auth: configPath([".local", "share", "kilo", "auth.json"], options),
+        vscodeSettings:
+          process.platform === "win32"
+            ? path.join(getAppData(options), "Code", "User", "settings.json")
+            : roamingConfigPath(["Code", "User", "settings.json"], options),
+      };
+    case "droid":
+      return {
+        settings: configPath([".factory", "settings.json"], options),
+      };
+    default:
+      return {};
+  }
+}

package/src/wizard.mjs

@@ -0,0 +1,160 @@
+import {
+  DEFAULT_BASE_URL,
+  DEFAULT_FAST_MODEL,
+  DEFAULT_MODEL,
+  TOOL_DEFINITIONS,
+} from "./constants.mjs";
+import { printBanner } from "./banner.mjs";
+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";
+
+function printHeader() {
+  printBanner();
+}
+
+function statusLabel(tool) {
+  if (tool.installed && tool.configStatus === "configured") return "installed, configured";
+  if (tool.installed) return "installed";
+  return "not installed";
+}
+
+function printTools(tools) {
+  console.log("Select a coding tool:");
+  tools.forEach((tool, index) => {
+    console.log(`  ${index + 1}. ${tool.name} (${statusLabel(tool)})`);
+  });
+}
+
+function resolveSelection(selection, tools) {
+  const trimmed = String(selection || "")
+    .trim()
+    .toLowerCase();
+  if (!trimmed) return null;
+  if (TOOL_DEFINITIONS[trimmed]) return trimmed;
+  const number = Number.parseInt(trimmed, 10);
+  if (Number.isInteger(number) && number >= 1 && number <= tools.length) {
+    return tools[number - 1].id;
+  }
+  return null;
+}
+
+async function maybeInstallTool(toolId, options, rl) {
+  const tool = await detectTool(toolId);
+  if (tool?.installed) return tool;
+
+  console.log(`\n${tool.name} is not installed.`);
+  console.log(`Install command: ${tool.installHint}`);
+  if (options.noInstall || !tool.canAutoInstall) return tool;
+
+  const shouldInstall =
+    options.yes || (await ask(rl, "Install it now? [y/N] ")).toLowerCase() === "y";
+  if (!shouldInstall) return tool;
+
+  console.log(`\nInstalling ${tool.name}. Please wait...\n`);
+  await runInstallCommand(toolId);
+  return detectTool(toolId);
+}
+
+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.");
+
+  const rl = createPromptInterface();
+  try {
+    const tools = await detectAllTools();
+    printTools(tools);
+    const answer = options.tool || (await ask(rl, "\nEnter tool number: "));
+    const toolId = resolveSelection(answer, tools);
+    if (!toolId) throw new Error("Invalid tool selection");
+
+    const installedTool = await maybeInstallTool(toolId, options, rl);
+    if (!installedTool?.installed && !options.dryRun) {
+      console.log(`\nInstall ${installedTool.name} first, then rerun: npx @kesarcloud/omega-plus-cli`);
+      return { toolId, skipped: true, reason: "not_installed" };
+    }
+
+    console.log("\nPlease wait while Omega Plus configures your tool...");
+    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(`  configured: ${file.path}`);
+      if (file.backupPath) console.log(`  backup: ${file.backupPath}`);
+    });
+    console.log("\nYou can start using the selected coding tool with Omega Plus.");
+    return result;
+  } finally {
+    rl.close();
+  }
+}
+
+export async function runNonInteractiveConfigure(options = {}) {
+  if (!options.tool) throw new Error("--tool is required");
+  if (!options.apiKey) throw new Error("--api-key is required");
+  await validateApiKey(options.apiKey, {
+    baseUrl: options.baseUrl || DEFAULT_BASE_URL,
+    validationUrl: options.validationUrl,
+    skipKeyValidation: options.skipKeyValidation,
+  });
+  const result = await configureTool(options.tool, {
+    apiKey: options.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("Dry run complete. No files were changed.");
+    result.files.forEach((file) => console.log(`would write: ${file.path}`));
+  } else {
+    console.log(result.message);
+    result.files.forEach((file) => console.log(`configured: ${file.path}`));
+  }
+
+  return result;
+}
+
+export async function printToolList() {
+  const tools = await detectAllTools();
+  printTools(tools);
+  return tools;
+}
+
+export async function printDoctor() {
+  const tools = await detectAllTools();
+  console.log("Omega Plus CLI Doctor\n");
+  for (const tool of tools) {
+    console.log(`${tool.name}: ${statusLabel(tool)}`);
+    console.log(`  command: ${tool.command || "not found"}`);
+    console.log(`  config: ${tool.configPath || "n/a"}`);
+  }
+  return tools;
+}