chore: import upstream snapshot with attribution

bin/cli/commands/setup.mjs

@@ -0,0 +1,211 @@
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { createPrompt, printHeading, printInfo, printSuccess } from "../io.mjs";
+import { openOmniRouteDb } from "../sqlite.mjs";
+import { getSettings, hashManagementPassword, updateSettings } from "../settings-store.mjs";
+import { testProviderApiKey } from "../provider-test.mjs";
+import { updateProviderTestResult, upsertApiKeyProviderConnection } from "../provider-store.mjs";
+import {
+  formatProviderChoices,
+  getProviderDisplayName,
+  resolveProviderChoice,
+} from "../provider-catalog.mjs";
+import { registerSetupOpenCode } from "./setup-open-code.mjs";
+import { t } from "../i18n.mjs";
+
+const PROJECT_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");
+
+async function getListCliTools() {
+  const { listCliTools } = await import(`${PROJECT_ROOT}/src/shared/constants/cliTools.ts`);
+  return listCliTools;
+}
+
+function wantsProviderSetup(opts) {
+  return opts.addProvider || Boolean(opts.provider) || Boolean(opts.apiKey);
+}
+
+async function resolvePassword(opts, prompt, nonInteractive) {
+  if (opts.password) return opts.password;
+  if (nonInteractive) return "";
+
+  const answer = await prompt.ask("Set an admin password now? [y/N]", "N");
+  if (!/^y(es)?$/i.test(answer)) return "";
+
+  const password = await prompt.askSecret("Admin password");
+  const confirm = await prompt.askSecret("Confirm password");
+  if (password !== confirm) {
+    throw new Error("Passwords do not match.");
+  }
+  return password;
+}
+
+async function setupPassword(db, opts, prompt, nonInteractive) {
+  const password = await resolvePassword(opts, prompt, nonInteractive);
+  if (!password) {
+    const settings = getSettings(db);
+    if (!settings.password) {
+      updateSettings(db, { requireLogin: false });
+    }
+    if (!nonInteractive) {
+      printInfo("Password setup skipped. Dashboard login remains disabled.");
+    }
+    return false;
+  }
+
+  if (password.length < 8) {
+    throw new Error("Password must be at least 8 characters.");
+  }
+
+  const hashedPassword = await hashManagementPassword(password);
+  updateSettings(db, {
+    password: hashedPassword,
+    requireLogin: true,
+  });
+  printSuccess("Admin password configured");
+  return true;
+}
+
+async function resolveProviderInput(opts, prompt, nonInteractive) {
+  let provider = opts.provider;
+  let apiKey = opts.apiKey;
+  let name = opts.providerName;
+  const defaultModel = opts.defaultModel;
+  const baseUrl = opts.providerBaseUrl;
+
+  if (!provider && !nonInteractive) {
+    console.log("Choose a provider:");
+    console.log(formatProviderChoices());
+    provider = resolveProviderChoice(await prompt.ask("Provider", "1"));
+  }
+
+  provider = provider || "openai";
+  if (!apiKey && !nonInteractive) {
+    apiKey = await prompt.ask(`${getProviderDisplayName(provider)} API key`);
+  }
+
+  if (!apiKey) {
+    throw new Error("Provider API key is required. Pass --api-key or OMNIROUTE_API_KEY.");
+  }
+
+  if (!name) {
+    name = getProviderDisplayName(provider);
+  }
+
+  return {
+    provider,
+    apiKey,
+    name,
+    defaultModel: defaultModel || null,
+    providerSpecificData: baseUrl ? { baseUrl } : null,
+  };
+}
+
+async function setupProvider(db, opts, prompt, nonInteractive) {
+  if (!wantsProviderSetup(opts) && nonInteractive) return null;
+
+  if (!wantsProviderSetup(opts)) {
+    const answer = await prompt.ask("Add your first provider now? [Y/n]", "Y");
+    if (/^n(o)?$/i.test(answer)) return null;
+  }
+
+  const input = await resolveProviderInput(opts, prompt, nonInteractive);
+  const connection = upsertApiKeyProviderConnection(db, input);
+  printSuccess(`Provider configured: ${connection.name}`);
+
+  if (opts.testProvider) {
+    printInfo(`Testing provider connection: ${connection.provider}`);
+    const result = await testProviderApiKey({
+      provider: input.provider,
+      apiKey: input.apiKey,
+      defaultModel: input.defaultModel,
+      baseUrl: input.providerSpecificData?.baseUrl || null,
+    });
+    updateProviderTestResult(db, connection.id, result);
+
+    if (result.valid) {
+      printSuccess("Provider test passed");
+    } else {
+      printInfo(`Provider test failed: ${result.error || "unknown error"}`);
+    }
+  }
+
+  return connection;
+}
+
+export function registerSetup(program) {
+  program
+    .command("setup")
+    .description(t("setup.title"))
+    .option("--password <value>", "Set admin password")
+    .option("--add-provider", "Add an API-key provider connection")
+    .option("--provider <id>", "Provider id, for example openai or anthropic")
+    .option("--provider-name <name>", "Display name for the connection")
+    .option("--api-key <value>", "Provider API key")
+    .option("--default-model <model>", "Optional default model")
+    .option("--provider-base-url <url>", "Optional OpenAI-compatible base URL override")
+    .option("--test-provider", "Test the provider after saving it")
+    .option("--non-interactive", "Read all inputs from flags/env and do not prompt")
+    .option("--list", "List all supported CLI tools")
+    .action(async (opts, cmd) => {
+      const globalOpts = cmd.optsWithGlobals();
+      const exitCode = await runSetupCommand({ ...opts, output: globalOpts.output });
+      if (exitCode !== 0) process.exit(exitCode);
+    });
+
+  // Wire up `omniroute setup opencode` subcommand. Kept inside registerSetup
+  // so it always travels with the parent command (avoids a separate register
+  // call in the registry that would silently break if the parent renames).
+  registerSetupOpenCode(program.commands.find((c) => c.name() === "setup"));
+}
+
+export async function runSetupCommand(opts = {}) {
+  if (opts.list) {
+    const listCliTools = await getListCliTools();
+    const tools = listCliTools();
+    if (opts.json || opts.output === "json") {
+      console.log(JSON.stringify(tools, null, 2));
+    } else {
+      printHeading("Supported CLI Tools");
+      for (const tool of tools) {
+        const cmd = tool.defaultCommand || tool.defaultCommands?.[0] || "";
+        const cmdStr = cmd ? `  \x1b[2m(${cmd})\x1b[0m` : "";
+        console.log(`  • ${tool.name}${cmdStr}`);
+      }
+    }
+    return 0;
+  }
+
+  const nonInteractive = opts.nonInteractive ?? false;
+  const prompt = createPrompt();
+
+  try {
+    printHeading("OmniRoute Setup");
+    const { db, dbPath } = await openOmniRouteDb();
+    printInfo(`Database: ${dbPath}`);
+
+    const before = getSettings(db);
+    const passwordChanged = await setupPassword(db, opts, prompt, nonInteractive);
+    const providerConnection = await setupProvider(db, opts, prompt, nonInteractive);
+
+    updateSettings(db, { setupComplete: true });
+    const after = getSettings(db);
+    db.close();
+
+    console.log("");
+    printSuccess("Setup complete");
+    printInfo(
+      `Login: ${after.requireLogin === true ? "enabled" : "disabled"}${
+        passwordChanged ? " (password updated)" : ""
+      }`
+    );
+    if (providerConnection) {
+      printInfo(`Provider: ${providerConnection.provider} (${providerConnection.name})`);
+    } else if (!before.setupComplete) {
+      printInfo("Provider: skipped");
+    }
+
+    return 0;
+  } finally {
+    prompt.close();
+  }
+}