@openexpert/opencore 0.1.0

package/README.md

@@ -0,0 +1,22 @@
+# OpenCore
+
+Motor abierto (MIT) de OpenExpert. Se descarga y funciona en tu máquina, sin
+crear cuentas ni depender de la nube. OpenExpert es **local-first**: no hay
+edición cloud.
+
+## Qué incluye
+
+- `src/model-provider.ts` — elige modelo (Gemini, BYOK, Ollama local).
+- `src/config.ts` — lee `openexpert.json` + `OPENEXPERT_*`.
+- `src/storage.ts` — interfaz de guardado local.
+- `src/secrets.ts` — interfaz de tokens de Drive (fichero local, `0600`).
+- `src/tools.ts` — catálogo de las 14 herramientas y sus dominios.
+- `src/cli/` — el CLI `opencore` (asistente, doctor, fix, models, serve, update).
+
+## Uso
+
+```sh
+npx @openexpert/opencore
+```
+
+Ver `openexpert.json.example` en la raíz y `docs/en/11-opencore.md`.

package/bin/opencore.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+// SPDX-License-Identifier: MIT
+// Thin launcher for the OpenCore CLI. The implementation lives in
+// src/cli.ts and is compiled to dist/cli.js. If the package has not been
+// built yet (source checkout), a clear instruction is printed.
+
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const dist = join(here, "..", "dist", "cli.js");
+
+if (!existsSync(dist)) {
+  console.error(
+    "OpenCore CLI is not built yet.\n" +
+      "Run: npm run build --workspace @openexpert/opencore\n" +
+      "(or use `npm run opencore:doctor` from the repository root).",
+  );
+  process.exit(1);
+}
+
+const mod = await import(dist);
+await mod.run(process.argv.slice(2));

package/dist/cli.d.ts

@@ -0,0 +1,3 @@
+declare function run(argv: string[]): Promise<void>;
+
+export { run };

package/dist/cli.js

@@ -0,0 +1,622 @@
+import { existsSync, rmSync, mkdirSync, writeFileSync, readFileSync, statSync, readdirSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import { spawn, spawnSync } from 'child_process';
+import { createHash } from 'crypto';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import * as p from '@clack/prompts';
+
+// src/cli/commands.ts
+
+// src/model-provider.ts
+function ollamaApiBaseUrl(baseUrl) {
+  return baseUrl.trim().replace(/\/+$/, "").replace(/\/v1$/, "");
+}
+var DEFAULT_OLLAMA_URL = "http://localhost:11434";
+var DEFAULT_DATA_DIR = "~/.openexpert";
+function expandHome(p2) {
+  if (p2 === "~") return homedir();
+  if (p2.startsWith("~/")) return join(homedir(), p2.slice(2));
+  return p2;
+}
+function packageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function packageVersion() {
+  try {
+    const pkg = JSON.parse(readFileSync(join(packageRoot(), "package.json"), "utf8"));
+    return pkg.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function findRepoRoot(start = process.cwd()) {
+  let dir = resolve(start);
+  for (let i = 0; i < 8; i++) {
+    if (existsSync(join(dir, "package.json")) && existsSync(join(dir, "packages", "opencore")) && existsSync(join(dir, "vite.config.ts"))) {
+      return dir;
+    }
+    const parent = resolve(dir, "..");
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function configPath(cwd = process.cwd()) {
+  return join(cwd, "openexpert.json");
+}
+function readConfig(cwd = process.cwd()) {
+  try {
+    const p2 = configPath(cwd);
+    if (!existsSync(p2)) return {};
+    return JSON.parse(readFileSync(p2, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeConfig(cfg, cwd = process.cwd()) {
+  writeFileSync(configPath(cwd), JSON.stringify(cfg, null, 2) + "\n");
+}
+function resolvedDataDir(cwd = process.cwd()) {
+  const cfg = readConfig(cwd);
+  const raw = process.env["OPENEXPERT_DATA_DIR"] || cfg.dataDir || DEFAULT_DATA_DIR;
+  return expandHome(raw);
+}
+function secretsPath(cwd = process.cwd()) {
+  return join(resolvedDataDir(cwd), "secrets.json");
+}
+function readSecrets(cwd = process.cwd()) {
+  try {
+    const p2 = secretsPath(cwd);
+    if (!existsSync(p2)) return {};
+    return JSON.parse(readFileSync(p2, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function writeSecrets(secrets, cwd = process.cwd()) {
+  const dir = resolvedDataDir(cwd);
+  mkdirSync(dir, { recursive: true });
+  const p2 = join(dir, "secrets.json");
+  writeFileSync(p2, JSON.stringify(secrets, null, 2), { mode: 384 });
+  return p2;
+}
+function secretsAsEnv(cwd = process.cwd()) {
+  const s = readSecrets(cwd);
+  const out = {};
+  for (const [k, v] of Object.entries(s)) if (v) out[k] = v;
+  return out;
+}
+async function httpGetJson(url, opts = {}) {
+  try {
+    const res = await fetch(url, {
+      ...opts.headers ? { headers: opts.headers } : {},
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 2500)
+    });
+    if (!res.ok) return null;
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function detectOllama(baseUrl = DEFAULT_OLLAMA_URL, timeoutMs = 1500) {
+  const root = ollamaApiBaseUrl(baseUrl);
+  const data = await httpGetJson(`${root}/api/tags`, {
+    timeoutMs
+  });
+  if (!data) return { up: false, models: [] };
+  return { up: true, models: (data.models ?? []).map((m) => m.name) };
+}
+function appCacheDir(version) {
+  return join(expandHome(DEFAULT_DATA_DIR), "app", version);
+}
+async function ensureStandaloneApp(version, opts = {}) {
+  const dir = appCacheDir(version);
+  const entry = join(dir, ".output", "server", "index.mjs");
+  if (existsSync(entry)) return dir;
+  const repo = opts.repo ?? "OpenExpert-ai/OpenExpert";
+  const log = opts.log ?? (() => {
+  });
+  const tarball = `openexpert-server-${version}.tar.gz`;
+  const tags = [`v${version}`, `@openexpert/opencore@${version}`, version];
+  for (const tag of tags) {
+    const base = `https://github.com/${repo}/releases/download/${tag}`;
+    const url = `${base}/${tarball}`;
+    log(`downloading ${url}`);
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(6e4) });
+      if (!res.ok) continue;
+      const buf = Buffer.from(await res.arrayBuffer());
+      try {
+        const shaRes = await fetch(`${base}/${tarball}.sha256`, {
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (shaRes.ok) {
+          const expected = (await shaRes.text()).trim().split(/\s+/)[0];
+          const actual = createHash("sha256").update(buf).digest("hex");
+          if (expected && expected !== actual) {
+            log("checksum mismatch, aborting");
+            return null;
+          }
+        }
+      } catch {
+      }
+      mkdirSync(dir, { recursive: true });
+      const tmp = join(dir, tarball);
+      writeFileSync(tmp, buf);
+      const r = spawnSync("tar", ["-xzf", tmp, "-C", dir], { stdio: "ignore" });
+      if (r.status !== 0) return null;
+      return existsSync(entry) ? dir : null;
+    } catch {
+    }
+  }
+  return null;
+}
+function run(cmd, args, opts = {}) {
+  return new Promise((res) => {
+    const child = spawn(cmd, args, { stdio: "inherit", cwd: opts.cwd, env: opts.env });
+    const forward = (sig) => () => child.kill(sig);
+    process.on("SIGINT", forward("SIGINT"));
+    process.on("SIGTERM", forward("SIGTERM"));
+    child.on("exit", (code) => res(code ?? 0));
+  });
+}
+
+// src/cli/commands.ts
+function cmdVersion() {
+  console.log(`@openexpert/opencore ${packageVersion()}`);
+  return 0;
+}
+function configuredProvider() {
+  const raw = process.env["OPENEXPERT_MODEL_PROVIDER"] || readConfig().modelProvider;
+  if (raw === "ollama" || raw === "openai-compatible") return raw;
+  return "google";
+}
+function cmdDoctor(cwd = process.cwd()) {
+  const provider = configuredProvider();
+  const dataDir = resolvedDataDir(cwd);
+  const secrets = readSecrets(cwd);
+  console.log("OpenCore doctor");
+  console.log(`  provider: ${provider}`);
+  console.log(`  data dir: ${dataDir}`);
+  const problems = [];
+  if (provider === "google" && !process.env["GOOGLE_API_KEY"] && !secrets.GOOGLE_API_KEY) {
+    problems.push("Falta GOOGLE_API_KEY. Ejecuta `opencore init` o usa Ollama.");
+  }
+  if (provider === "openai-compatible") {
+    if (!process.env["OPENEXPERT_MODEL_KEY"] && !secrets.OPENEXPERT_MODEL_KEY) {
+      problems.push("Falta OPENEXPERT_MODEL_KEY.");
+    }
+    if (!process.env["OPENEXPERT_BASE_URL"] && !secrets.OPENEXPERT_BASE_URL) {
+      problems.push("Falta OPENEXPERT_BASE_URL.");
+    }
+  }
+  if (provider === "ollama") {
+    console.log(`  ollama:   ${process.env["OLLAMA_BASE_URL"] || DEFAULT_OLLAMA_URL}`);
+  }
+  if (!process.env["GOOGLE_CLIENT_ID"] && !secrets.GOOGLE_CLIENT_ID) {
+    console.log("  note:     sin Google OAuth el chat funciona; Drive queda desconectado.");
+  }
+  try {
+    mkdirSync(dataDir, { recursive: true });
+  } catch {
+    problems.push(`No se puede escribir en ${dataDir}.`);
+  }
+  if (!problems.length) {
+    console.log("  OK: listo para arrancar.");
+    return 0;
+  }
+  console.log("  pendiente:");
+  for (const x of problems) console.log(`  - ${x}`);
+  return 1;
+}
+async function cmdFix(cwd = process.cwd()) {
+  const dataDir = resolvedDataDir(cwd);
+  mkdirSync(dataDir, { recursive: true });
+  if (!existsSync(join(cwd, "openexpert.json"))) {
+    const ollama = await detectOllama();
+    writeConfig(
+      {
+        modelProvider: "ollama",
+        modelId: ollama.models[0] ?? "llama3.1",
+        ollamaBaseUrl: DEFAULT_OLLAMA_URL,
+        dataDir: "~/.openexpert"
+      },
+      cwd
+    );
+    console.log("\u2713 openexpert.json creado (Ollama).");
+  } else {
+    console.log("\u2022 openexpert.json ya existe.");
+  }
+  const secrets = readSecrets(cwd);
+  if (Object.keys(secrets).length) {
+    const p2 = join(dataDir, "secrets.json");
+    writeFileSync(p2, JSON.stringify(secrets, null, 2), { mode: 384 });
+    console.log(`\u2713 permisos de ${p2} normalizados (0600).`);
+  }
+  console.log("\u2713 directorio de datos listo:", dataDir);
+  cmdDoctor(cwd);
+  console.log("\nSiguiente paso: `opencore serve` (o `opencore init` para elegir modelo).");
+  return 0;
+}
+async function cmdModels(cwd = process.cwd()) {
+  const provider = configuredProvider();
+  const secrets = readSecrets(cwd);
+  const cfg = readConfig(cwd);
+  if (provider === "ollama") {
+    const base = ollamaApiBaseUrl(
+      process.env["OLLAMA_BASE_URL"] || cfg.ollamaBaseUrl || DEFAULT_OLLAMA_URL
+    );
+    const { up, models } = await detectOllama(base);
+    if (!up) {
+      console.log(`No se puede contactar con Ollama en ${base}.`);
+      console.log("Inst\xE1lalo con: curl -fsSL https://ollama.com/install.sh | sh");
+      return 1;
+    }
+    console.log(`Modelos en Ollama (${base}):`);
+    for (const m of models) console.log(`  ${m === cfg.modelId ? "*" : " "} ${m}`);
+    if (!models.length) console.log("  (ninguno; prueba `ollama pull llama3.1`)");
+    return 0;
+  }
+  if (provider === "openai-compatible") {
+    const base = process.env["OPENEXPERT_BASE_URL"] || secrets.OPENEXPERT_BASE_URL;
+    const key = process.env["OPENEXPERT_MODEL_KEY"] || secrets.OPENEXPERT_MODEL_KEY;
+    if (!base || !key) {
+      console.log("Configura OPENEXPERT_BASE_URL y OPENEXPERT_MODEL_KEY (opencore init).");
+      return 1;
+    }
+    const data = await httpGetJson(
+      `${base.replace(/\/+$/, "")}/models`,
+      { headers: { Authorization: `Bearer ${key}` } }
+    );
+    if (!data) {
+      console.log("No se pudo listar modelos del endpoint.");
+      return 1;
+    }
+    console.log("Modelos disponibles:");
+    for (const m of data.data ?? []) console.log(`  ${m.id === cfg.modelId ? "*" : " "} ${m.id}`);
+    return 0;
+  }
+  console.log("Proveedor google: usa `gemini-2.5-flash` o consulta Google AI Studio.");
+  return 0;
+}
+async function cmdServe(cwd = process.cwd()) {
+  const env = { ...process.env, ...secretsAsEnv(cwd) };
+  const repo = findRepoRoot(cwd);
+  if (repo) {
+    console.log("Arrancando OpenExpert (desde el c\xF3digo fuente)\u2026");
+    return run("npm", ["run", "dev"], { cwd: repo, env });
+  }
+  const version = packageVersion();
+  const app = await ensureStandaloneApp(version, { log: (m) => console.log(`  ${m}`) });
+  if (!app) {
+    console.error(
+      "No hay un servidor preconstruido disponible y no se pudo descargar.\nOpciones:\n  \u2022 Usa Docker:  docker run -p 3000:3000 -v openexpert-data:/data ghcr.io/openexpert-ai/openexpert:local\n  \u2022 O clona el repositorio y ejecuta `npm ci && npm run dev`."
+    );
+    return 1;
+  }
+  console.log("Arrancando OpenCore en http://localhost:3000 \u2026");
+  return run(process.execPath, [join(app, ".output", "server", "index.mjs")], {
+    cwd: app,
+    env: { ...env, PORT: process.env["PORT"] || "3000" }
+  });
+}
+function cmdUpdate() {
+  const dir = appCacheDir(packageVersion());
+  if (existsSync(dir)) {
+    rmSync(dir, { recursive: true, force: true });
+    console.log(`\u2713 cach\xE9 del servidor eliminada (${dir}).`);
+  } else {
+    console.log("No hay servidor descargado que actualizar.");
+  }
+  return 0;
+}
+function port() {
+  return process.env["PORT"] || "3000";
+}
+function appUrl() {
+  return `http://localhost:${port()}`;
+}
+async function isServerUp(timeoutMs = 1500) {
+  try {
+    const res = await fetch(appUrl(), { signal: AbortSignal.timeout(timeoutMs) });
+    return res.status < 500;
+  } catch {
+    return false;
+  }
+}
+async function waitForServer(timeoutMs = 12e4) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await isServerUp()) return true;
+    await new Promise((r) => setTimeout(r, 400));
+  }
+  return false;
+}
+function resolveRepo(cwd) {
+  const fromEnv = process.env["OPENEXPERT_DESKTOP_REPO"];
+  if (fromEnv) {
+    const r = findRepoRoot(fromEnv);
+    if (r) return r;
+  }
+  return findRepoRoot(packageRoot()) ?? findRepoRoot(cwd);
+}
+function newestMtime(dir) {
+  let newest = 0;
+  try {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) newest = Math.max(newest, newestMtime(full));
+      else if (entry.isFile()) newest = Math.max(newest, statSync(full).mtimeMs);
+    }
+  } catch {
+  }
+  return newest;
+}
+function buildIsFresh(repo) {
+  const built = join(repo, ".output", "server", "index.mjs");
+  if (!existsSync(built)) return false;
+  try {
+    return statSync(built).mtimeMs >= newestMtime(join(repo, "src"));
+  } catch {
+    return true;
+  }
+}
+async function spawnServer(cwd, env) {
+  const repo = resolveRepo(cwd);
+  if (repo) {
+    const built = join(repo, ".output", "server", "index.mjs");
+    if (existsSync(built) && buildIsFresh(repo)) {
+      return spawn(process.execPath, [built], {
+        cwd: repo,
+        env: { ...env, NODE_ENV: "production", PORT: port() },
+        stdio: "inherit"
+      });
+    }
+    console.log(
+      existsSync(built) ? "La build est\xE1 desactualizada; arrancando en modo desarrollo\u2026" : "Arrancando el servidor en modo desarrollo (no hay build)\u2026"
+    );
+    return spawn("npm", ["run", "dev"], { cwd: repo, env, stdio: "inherit" });
+  }
+  const app = await ensureStandaloneApp(packageVersion(), { log: (m) => console.log(`  ${m}`) });
+  if (!app) return null;
+  return spawn(process.execPath, [join(app, ".output", "server", "index.mjs")], {
+    cwd: app,
+    env: { ...env, NODE_ENV: "production", PORT: port() },
+    stdio: "inherit"
+  });
+}
+function findDesktopBinary(cwd) {
+  const fromEnv = process.env["OPENEXPERT_DESKTOP_BIN"];
+  if (fromEnv && existsSync(fromEnv)) return fromEnv;
+  const candidates = [join(homedir(), ".local", "bin", "openexpert-desktop")];
+  const repo = resolveRepo(cwd);
+  if (repo) {
+    candidates.push(
+      join(repo, "src-tauri", "target", "release", "openexpert-desktop"),
+      join(repo, "src-tauri", "target", "debug", "openexpert-desktop")
+    );
+  }
+  return candidates.find((c) => existsSync(c)) ?? null;
+}
+async function cmdDesktop(cwd = process.cwd()) {
+  const env = { ...process.env, ...secretsAsEnv(cwd) };
+  const bin = findDesktopBinary(cwd);
+  if (!bin) {
+    console.error(
+      "No se encontr\xF3 la ventana de escritorio (openexpert-desktop).\nComp\xEDlala con `npx tauri build` o usa `npm run desktop:install`."
+    );
+    return 1;
+  }
+  let server = null;
+  let startedServer = false;
+  if (await isServerUp()) {
+    console.log(`\u2022 Usando el servidor ya activo en ${appUrl()}`);
+  } else {
+    console.log("Arrancando el servidor local\u2026");
+    server = await spawnServer(cwd, env);
+    if (!server) {
+      console.error(
+        "No se pudo arrancar el servidor.\nSi usas el c\xF3digo fuente, entra en el repositorio y ejecuta:\n  npm ci && npm run build && npm run desktop:install"
+      );
+      return 1;
+    }
+    startedServer = true;
+    if (!await waitForServer()) {
+      console.error("El servidor no respondi\xF3 a tiempo.");
+      server.kill("SIGTERM");
+      return 1;
+    }
+  }
+  const stopServer = () => {
+    if (startedServer && server && !server.killed) {
+      try {
+        server.kill("SIGTERM");
+      } catch {
+      }
+    }
+  };
+  const onSignal = () => {
+    stopServer();
+    process.exit(0);
+  };
+  process.once("SIGINT", onSignal);
+  process.once("SIGTERM", onSignal);
+  console.log("Abriendo la ventana de OpenExpert\u2026");
+  const code = await new Promise((resolve2) => {
+    const win = spawn(bin, [], { stdio: "inherit", env });
+    win.on("exit", (c) => resolve2(c ?? 0));
+  });
+  stopServer();
+  return code;
+}
+function bail() {
+  p.cancel("Configuraci\xF3n cancelada.");
+  process.exit(1);
+}
+async function runWizard(opts = {}) {
+  const cwd = opts.cwd ?? process.cwd();
+  const existing = readConfig(cwd);
+  const nonInteractive = opts.assumeYes || !process.stdin.isTTY;
+  if (nonInteractive) {
+    const ollama2 = await detectOllama();
+    const config2 = {
+      modelProvider: "ollama",
+      modelId: ollama2.models[0] ?? "llama3.1",
+      ollamaBaseUrl: DEFAULT_OLLAMA_URL,
+      dataDir: "~/.openexpert"
+    };
+    writeConfig(config2, cwd);
+    return { config: config2, secrets: {}, provider: "ollama", modelId: config2.modelId, started: false };
+  }
+  p.intro("OpenCore \u2014 configuraci\xF3n");
+  const spin = p.spinner();
+  spin.start("Buscando Ollama local\u2026");
+  const ollama = await detectOllama();
+  spin.stop(
+    ollama.up ? `Ollama detectado (${ollama.models.length} modelo(s))` : "No se ha detectado Ollama"
+  );
+  const choice = await p.select({
+    message: "\xBFQu\xE9 modelo quieres usar?",
+    options: [
+      ...ollama.up ? [
+        {
+          value: "ollama",
+          label: "Modelo local (Ollama)",
+          hint: "sin claves, datos en tu equipo"
+        }
+      ] : [],
+      { value: "google", label: "Google Gemini (clave gratuita)", hint: "AI Studio" },
+      { value: "openai-compatible", label: "Otro endpoint compatible", hint: "BYOK" },
+      ...!ollama.up ? [{ value: "install-ollama", label: "Instalar Ollama", hint: "te muestro c\xF3mo" }] : []
+    ]
+  });
+  if (p.isCancel(choice)) bail();
+  if (choice === "install-ollama") {
+    p.note(
+      "Instala Ollama y descarga un modelo:\n\n  curl -fsSL https://ollama.com/install.sh | sh\n  ollama pull llama3.1\n\nVuelve a ejecutar `opencore init` cuando est\xE9 listo.",
+      "Instalar Ollama"
+    );
+    p.outro("Sin cambios.");
+    process.exit(0);
+  }
+  const config = { dataDir: "~/.openexpert" };
+  const secrets = {};
+  let modelId = "llama3.1";
+  if (choice === "ollama") {
+    const models = ollama.models.length ? ollama.models : ["llama3.1"];
+    const picked = await p.select({
+      message: "Modelo de Ollama",
+      options: models.map((m) => ({ value: m, label: m }))
+    });
+    if (p.isCancel(picked)) bail();
+    modelId = String(picked);
+    config.modelProvider = "ollama";
+    config.modelId = modelId;
+    config.ollamaBaseUrl = DEFAULT_OLLAMA_URL;
+  } else if (choice === "google") {
+    const apiKey = await p.password({ message: "GOOGLE_API_KEY (AI Studio)" });
+    if (p.isCancel(apiKey)) bail();
+    const id = await p.text({ message: "Modelo", initialValue: "gemini-2.5-flash" });
+    if (p.isCancel(id)) bail();
+    modelId = String(id) || "gemini-2.5-flash";
+    config.modelProvider = "google";
+    config.modelId = modelId;
+    secrets.GOOGLE_API_KEY = String(apiKey);
+  } else if (choice === "openai-compatible") {
+    const baseURL = await p.text({ message: "Base URL (\u2026/v1)", initialValue: "" });
+    if (p.isCancel(baseURL)) bail();
+    const apiKey = await p.password({ message: "API key" });
+    if (p.isCancel(apiKey)) bail();
+    const id = await p.text({ message: "Modelo", initialValue: "gpt-4o-mini" });
+    if (p.isCancel(id)) bail();
+    modelId = String(id) || "gpt-4o-mini";
+    config.modelProvider = "openai-compatible";
+    config.modelId = modelId;
+    secrets.OPENEXPERT_BASE_URL = String(baseURL);
+    secrets.OPENEXPERT_MODEL_KEY = String(apiKey);
+  }
+  writeConfig({ ...existing, ...config }, cwd);
+  if (Object.keys(secrets).length) writeSecrets({ ...secrets }, cwd);
+  p.outro(
+    `Configuraci\xF3n guardada en openexpert.json (modelo: ${config.modelProvider}:${modelId}).`
+  );
+  const go = await p.confirm({ message: "\xBFArrancar ahora?", initialValue: true });
+  if (p.isCancel(go)) bail();
+  return {
+    config: { ...existing, ...config },
+    secrets,
+    provider: config.modelProvider,
+    modelId,
+    started: Boolean(go)
+  };
+}
+
+// src/cli.ts
+function help() {
+  console.log(`opencore \u2014 motor abierto de OpenExpert
+
+Uso:
+  opencore            asistente de configuraci\xF3n y arranque
+  opencore init       igual que sin argumentos
+  opencore serve      arranca la edici\xF3n local en http://localhost:3000
+  opencore desktop    arranca el servidor y abre la ventana de escritorio
+  opencore doctor     revisa tu configuraci\xF3n
+  opencore fix        auto-configura lo que falte
+  opencore models     lista los modelos del proveedor actual
+  opencore update     limpia la cach\xE9 del servidor descargado
+  opencore version    muestra la versi\xF3n
+
+Ejemplos:
+  npx @openexpert/opencore
+  npx @openexpert/opencore serve
+
+Docker (sin Node):
+  docker run -p 3000:3000 -v openexpert-data:/data ghcr.io/openexpert-ai/openexpert`);
+}
+async function run2(argv) {
+  const cmd = argv[0] ?? "";
+  switch (cmd) {
+    case "":
+    case "init":
+    case "setup": {
+      const res = await runWizard({});
+      if (res.started) process.exit(await cmdServe());
+      return;
+    }
+    case "doctor":
+      return process.exit(cmdDoctor());
+    case "fix":
+      return process.exit(await cmdFix());
+    case "models":
+      return process.exit(await cmdModels());
+    case "serve":
+    case "dev":
+      return process.exit(await cmdServe());
+    case "desktop":
+    case "app": {
+      const code = await cmdDesktop();
+      return process.exit(code);
+    }
+    case "update":
+      return process.exit(cmdUpdate());
+    case "version":
+    case "--version":
+    case "-v":
+      return process.exit(cmdVersion());
+    case "help":
+    case "--help":
+    case "-h":
+      help();
+      return;
+    default:
+      console.error(`Comando desconocido: ${cmd}
+`);
+      help();
+      return process.exit(1);
+  }
+}
+
+export { run2 as run };
+//# sourceMappingURL=cli.js.map
+//# sourceMappingURL=cli.js.map