9router 0.4.5 → 0.4.8

package/cli.js

@@ -79,6 +79,7 @@ for (let i = 0; i < args.length; i++) {
     skipUpdate = true;
   } else if (args[i] === "--tray" || args[i] === "-t") {
     trayMode = true;
+    process.env.TRAY_MODE = "1";
   } else if (args[i] === "--help" || args[i] === "-h") {
     console.log(`
 Usage: ${APP_NAME} [options]
@@ -114,16 +115,82 @@ function compareVersions(a, b) {
   return 0;
 }
 
+// Get app data dir (matches app/src/lib/dataDir.js convention)
+function getAppDataDir() {
+  return process.platform === "win32"
+    ? path.join(process.env.APPDATA || "", "9router")
+    : path.join(os.homedir(), ".9router");
+}
+
+// Kill PID from file (best-effort, removes file after)
+function killByPidFile(pidFile) {
+  try {
+    if (!fs.existsSync(pidFile)) return;
+    const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+    if (!pid) return;
+    try {
+      if (process.platform === "win32") {
+        execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 });
+      } else {
+        process.kill(pid, "SIGKILL");
+      }
+    } catch { }
+    try { fs.unlinkSync(pidFile); } catch { }
+  } catch { }
+}
+
+// Kill tunnel processes (cloudflared/tailscale) by their PID files
+function killTunnelByPidFile() {
+  const tunnelDir = path.join(getAppDataDir(), "tunnel");
+  killByPidFile(path.join(tunnelDir, "cloudflared.pid"));
+  killByPidFile(path.join(tunnelDir, "tailscale.pid"));
+}
+
+// Kill cloudflared whose --url targets this app's port (covers stale PID file case)
+function killCloudflaredByAppPort(appPort) {
+  if (!appPort) return [];
+  const portMatchers = [`localhost:${appPort}`, `127.0.0.1:${appPort}`];
+  const pids = [];
+  try {
+    if (process.platform === "win32") {
+      const psCmd = `powershell -NonInteractive -WindowStyle Hidden -Command "Get-WmiObject Win32_Process -Filter 'Name=\\"cloudflared.exe\\"' | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"`;
+      const output = execSync(psCmd, { encoding: "utf8", windowsHide: true, timeout: 5000 });
+      const lines = output.split("\n").slice(1).filter(l => l.trim());
+      lines.forEach(line => {
+        if (portMatchers.some(m => line.includes(m))) {
+          const match = line.match(/^"(\d+)"/);
+          if (match && match[1]) pids.push(match[1]);
+        }
+      });
+    } else {
+      const output = execSync("ps -eo pid,command 2>/dev/null", { encoding: "utf8", timeout: 5000 });
+      output.split("\n").forEach(line => {
+        if (line.includes("cloudflared") && portMatchers.some(m => line.includes(m))) {
+          const parts = line.trim().split(/\s+/);
+          const pid = parts[0];
+          if (pid && !isNaN(pid)) pids.push(pid);
+        }
+      });
+    }
+  } catch { }
+  return pids;
+}
+
 // Kill all 9router processes
-function killAllAppProcesses() {
+function killAllAppProcesses(appPort) {
   return new Promise((resolve) => {
     try {
       // Kill MITM first (admin/sudo process, needs special handling)
       killMitmByPidFile();
+      // Kill cloudflared/tailscale by PID file (precise, only this app's tunnel)
+      killTunnelByPidFile();
 
       const platform = process.platform;
       let pids = [];
 
+      // Catch stale PID files: kill cloudflared bound to this app's port
+      pids.push(...killCloudflaredByAppPort(appPort));
+
       if (platform === "win32") {
         // Windows: use WMI to get full CommandLine (tasklist /V doesn't include it)
         try {
@@ -147,18 +214,6 @@ function killAllAppProcesses() {
         } catch (e) {
           // No processes found or error - continue
         }
-
-        // Also kill cloudflared.exe (tunnel holds file locks on Windows)
-        try {
-          const cfCmd = `powershell -NonInteractive -WindowStyle Hidden -Command "Get-Process cloudflared -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id"`;
-          const cfOut = execSync(cfCmd, { encoding: "utf8", windowsHide: true, timeout: 5000 });
-          cfOut.split("\n").forEach(l => {
-            const pid = l.trim();
-            if (pid && !isNaN(pid)) pids.push(pid);
-          });
-        } catch (e) {
-          // No cloudflared running - continue
-        }
       } else {
         // macOS/Linux: use ps to find all matching processes
         try {
@@ -169,7 +224,7 @@ function killAllAppProcesses() {
           const lines = output.split('\n');
 
           lines.forEach(line => {
-            const isAppProcess = line.includes("9router") || line.includes("next-server") || line.includes("cloudflared");
+            const isAppProcess = line.includes("9router") || line.includes("next-server");
             if (isAppProcess) {
               const parts = line.trim().split(/\s+/);
               const pid = parts[1];
@@ -209,28 +264,43 @@ function killAllAppProcesses() {
   });
 }
 
+// Sleep helper using SharedArrayBuffer wait (sync, no busy-loop)
+function sleepSync(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch { /* ignore */ }
+}
+
+// Wait until process dies or timeout reached
+function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try { process.kill(pid, 0); } catch { return true; }
+    sleepSync(100);
+  }
+  return false;
+}
+
 // Kill MITM server by PID file (MITM runs as admin/sudo, needs special handling)
+// Sends SIGTERM first so MITM can clean up /etc/hosts entries before dying.
 function killMitmByPidFile() {
   try {
-    const mitmPidFile = path.join(
-      process.platform === "win32"
-        ? path.join(process.env.APPDATA || "", "9router")
-        : path.join(os.homedir(), ".9router"),
-      "mitm", ".mitm.pid"
-    );
+    const mitmPidFile = path.join(getAppDataDir(), "mitm", ".mitm.pid");
     if (!fs.existsSync(mitmPidFile)) return;
     const pid = parseInt(fs.readFileSync(mitmPidFile, "utf8").trim(), 10);
     if (!pid) return;
 
     if (process.platform === "win32") {
-      // Admin CLI → admin MITM → same token → OK
-      execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 });
+      // Graceful first (lets server cleanup hosts), then force
+      try { execSync(`taskkill /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 2000 }); } catch { }
+      if (!waitForExit(pid, 1500)) {
+        try { execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 }); } catch { }
+      }
     } else {
-      // Try sudo -n first (uses cached sudo token if still valid)
-      try { execSync(`sudo -n kill -9 ${pid} 2>/dev/null`, { stdio: "ignore", timeout: 3000 }); }
-      catch {
-        // Fallback: direct kill (works if MITM not root, or CLI is root)
-        try { process.kill(pid, "SIGKILL"); } catch { }
+      // SIGTERM via cached sudo token first
+      try { execSync(`sudo -n kill -TERM ${pid} 2>/dev/null`, { stdio: "ignore", timeout: 2000 }); }
+      catch { try { process.kill(pid, "SIGTERM"); } catch { } }
+      if (!waitForExit(pid, 1500)) {
+        try { execSync(`sudo -n kill -9 ${pid} 2>/dev/null`, { stdio: "ignore", timeout: 2000 }); }
+        catch { try { process.kill(pid, "SIGKILL"); } catch { } }
       }
     }
     try { fs.unlinkSync(mitmPidFile); } catch { }
@@ -382,7 +452,7 @@ if (!fs.existsSync(serverPath)) {
 
 // Check for updates FIRST, then start server
 checkForUpdate().then((latestVersion) => {
-  killAllAppProcesses().then(() => {
+  killAllAppProcesses(port).then(() => {
     return killProcessOnPort(port);
   }).then(() => {
     startServer(latestVersion);
@@ -486,6 +556,8 @@ function startServer(latestVersion) {
       } catch (e) { }
       // Kill MITM server (admin/sudo process) via PID file
       killMitmByPidFile();
+      // Kill cloudflared/tailscale via PID file (only this app's tunnel)
+      killTunnelByPidFile();
       // Kill server process directly
       if (server.pid) {
         process.kill(server.pid, "SIGKILL");
@@ -569,7 +641,7 @@ function startServer(latestVersion) {
           isShuttingDown = true;
           cleanup();
           // Kill ALL lingering processes (server/next-server/cloudflared/tray) to release file locks on Windows
-          await killAllAppProcesses();
+          await killAllAppProcesses(port);
           await killProcessOnPort(port);
           await new Promise(r => setTimeout(r, 1500));
           const { clearScreen } = require("./src/cli/utils/display");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "9router",
-  "version": "0.4.5",
+  "version": "0.4.8",
   "description": "9Router CLI - Start and manage 9Router server",
   "bin": {
     "9router": "./cli.js"

package/src/cli/menus/cliTools.js

@@ -1,5 +1,5 @@
 const api = require("../api/client");
-const { pause } = require("../utils/input");
+const { pause, confirm } = require("../utils/input");
 const { showStatus } = require("../utils/display");
 const { selectModelFromList } = require("../utils/modelSelector");
 const { showMenuWithBack } = require("../utils/menuHelper");
@@ -100,7 +100,7 @@ async function claudeQuickSetup(port) {
  */
 async function claudeSelectModel(modelType, port) {
   const current = await getClaudeModel(modelType.envKey);
-  const selected = await selectModelFromList(`Select ${modelType.name} Model`, current);
+  const selected = await selectModelFromList(`Select ${modelType.name} Model`, current, { excludeCombos: true });
   if (!selected) return;
 
   const env = { [modelType.envKey]: selected };
@@ -216,7 +216,7 @@ async function codexQuickSetup(port) {
   }
 
   // Get model selection
-  const model = await selectModelFromList("Select Codex Model", "cx/claude-sonnet-4-5-20250929");
+  const model = await selectModelFromList("Select Codex Model", "cx/claude-sonnet-4-5-20250929", { excludeCombos: true });
   if (!model) return;
 
   const result = await api.applyCliToolSettings("codex", { baseUrl: endpoint, apiKey, model });
@@ -299,7 +299,7 @@ async function droidQuickSetup(port) {
     return;
   }
 
-  const model = await selectModelFromList("Select Droid Model", "cc/claude-sonnet-4-5-20250929");
+  const model = await selectModelFromList("Select Droid Model", "cc/claude-sonnet-4-5-20250929", { excludeCombos: true });
   if (!model) return;
 
   const result = await api.applyCliToolSettings("droid", { baseUrl: endpoint, apiKey, model });
@@ -384,7 +384,7 @@ async function openClawQuickSetup(port) {
     return;
   }
 
-  const model = await selectModelFromList("Select OpenClaw Model", "cc/claude-sonnet-4-5-20250929");
+  const model = await selectModelFromList("Select OpenClaw Model", "cc/claude-sonnet-4-5-20250929", { excludeCombos: true });
   if (!model) return;
 
   const result = await api.applyCliToolSettings("openclaw", { baseUrl: endpoint, apiKey, model });
@@ -425,6 +425,154 @@ async function showOpenClawMenu(port, breadcrumb = []) {
   });
 }
 
+// ─── OpenCode CLI ─────────────────────────────────────────────────────────────
+
+async function buildOpenCodeHeader() {
+  const result = await api.getCliToolSettings("opencode");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const { installed, has9Router, opencode } = result.data;
+  if (!installed) return `Status:   ${COLORS.red}✗ OpenCode CLI not installed${COLORS.reset}`;
+
+  if (!has9Router) {
+    return [
+      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
+      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
+    ].join("\n");
+  }
+
+  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
+  if (opencode?.baseURL) lines.push(`Endpoint: ${COLORS.cyan}${opencode.baseURL}${COLORS.reset}`);
+  if (opencode?.activeModel) lines.push(`Active:   ${COLORS.dim}${opencode.activeModel}${COLORS.reset}`);
+  if (Array.isArray(opencode?.models) && opencode.models.length > 0) {
+    lines.push(`Models:   ${COLORS.dim}${opencode.models.join(", ")}${COLORS.reset}`);
+  }
+  return lines.join("\n");
+}
+
+async function openCodeQuickSetup(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
+    await pause();
+    return;
+  }
+
+  // Pick first model (also becomes active model by default)
+  const firstModel = await selectModelFromList("Select Active Model (OpenCode)", "", { excludeCombos: true });
+  if (!firstModel) return;
+
+  const models = [firstModel];
+
+  // Optionally add more models
+  while (true) {
+    const more = await confirm(`Add another model? (current: ${models.length})`);
+    if (!more) break;
+    const next = await selectModelFromList(`Add Model #${models.length + 1}`, models.join(", "), { excludeCombos: true });
+    if (!next) break;
+    if (!models.includes(next)) models.push(next);
+  }
+
+  // Optional subagent model
+  let subagentModel = firstModel;
+  const wantSubagent = await confirm(`Set a different subagent model? (default: ${firstModel})`);
+  if (wantSubagent) {
+    const picked = await selectModelFromList("Select Subagent Model", firstModel, { excludeCombos: true });
+    if (picked) subagentModel = picked;
+  }
+
+  const result = await api.applyCliToolSettings("opencode", {
+    baseUrl: endpoint,
+    apiKey,
+    models,
+    activeModel: firstModel,
+    subagentModel,
+  });
+  showStatus(result.success ? "OpenCode setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+async function openCodeReset() {
+  const result = await api.resetCliToolSettings("opencode");
+  showStatus(result.success ? "OpenCode settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+async function showOpenCodeMenu(port, breadcrumb = []) {
+  await showMenuWithBack({
+    title: "💻 OpenCode CLI Settings",
+    breadcrumb,
+    headerContent: buildOpenCodeHeader,
+    refresh: async () => ({}),
+    items: [
+      { label: "⚡ Quick Setup", action: async () => { await openCodeQuickSetup(port); return true; } },
+      { label: "Reset to Default", action: async () => { await openCodeReset(); return true; } }
+    ]
+  });
+}
+
+// ─── Hermes Agent ─────────────────────────────────────────────────────────────
+
+async function buildHermesHeader() {
+  const result = await api.getCliToolSettings("hermes");
+  if (!result.success) return `  ${COLORS.red}Failed to load settings${COLORS.reset}`;
+
+  const { installed, has9Router, settings } = result.data;
+  if (!installed) return `Status:   ${COLORS.red}✗ Hermes Agent not installed${COLORS.reset}`;
+
+  if (!has9Router) {
+    return [
+      `Status:   ${COLORS.red}✗ Not configured${COLORS.reset}`,
+      `${COLORS.dim}Run "Quick Setup" to configure${COLORS.reset}`
+    ].join("\n");
+  }
+
+  const model = settings?.model || {};
+  const lines = [`Status:   ${COLORS.green}✓ Configured${COLORS.reset}`];
+  if (model.base_url) lines.push(`Endpoint: ${COLORS.cyan}${model.base_url}${COLORS.reset}`);
+  if (model.default)  lines.push(`Model:    ${COLORS.dim}${model.default}${COLORS.reset}`);
+  return lines.join("\n");
+}
+
+async function hermesQuickSetup(port) {
+  const { endpoint } = await getEndpoint(port);
+  const apiKey = await getFirstApiKey();
+
+  if (!apiKey) {
+    showStatus("No API keys found. Create one in API Keys menu first.", "error");
+    await pause();
+    return;
+  }
+
+  const model = await selectModelFromList("Select Hermes Model", "", { excludeCombos: true });
+  if (!model) return;
+
+  const result = await api.applyCliToolSettings("hermes", { baseUrl: endpoint, apiKey, model });
+  showStatus(result.success ? "Hermes setup completed!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+async function hermesReset() {
+  const result = await api.resetCliToolSettings("hermes");
+  showStatus(result.success ? "Hermes settings reset!" : `Failed: ${result.error}`, result.success ? "success" : "error");
+  await pause();
+}
+
+async function showHermesMenu(port, breadcrumb = []) {
+  await showMenuWithBack({
+    title: "⚡ Hermes Agent Settings",
+    breadcrumb,
+    headerContent: buildHermesHeader,
+    refresh: async () => ({}),
+    items: [
+      { label: "⚡ Quick Setup", action: async () => { await hermesQuickSetup(port); return true; } },
+      { label: "Reset to Default", action: async () => { await hermesReset(); return true; } }
+    ]
+  });
+}
+
 // ─── Main CLI Tools Menu ──────────────────────────────────────────────────────
 
 /**
@@ -454,6 +602,14 @@ async function showCliToolsMenu(port, breadcrumb = []) {
       {
         label: "Open Claw",
         action: async () => { await showOpenClawMenu(port, [...breadcrumb, "Open Claw"]); return true; }
+      },
+      {
+        label: "OpenCode",
+        action: async () => { await showOpenCodeMenu(port, [...breadcrumb, "OpenCode"]); return true; }
+      },
+      {
+        label: "Hermes",
+        action: async () => { await showHermesMenu(port, [...breadcrumb, "Hermes"]); return true; }
       }
     ]
   });

package/src/cli/menus/settings.js

@@ -1,5 +1,8 @@
+const path = require("path");
+const fs = require("fs");
+const os = require("os");
 const api = require("../api/client");
-const { pause } = require("../utils/input");
+const { confirm, pause } = require("../utils/input");
 const { showStatus } = require("../utils/display");
 const { showMenuWithBack } = require("../utils/menuHelper");
 
@@ -9,50 +12,75 @@ const COLORS = {
   green: "\x1b[32m",
   red: "\x1b[31m",
   yellow: "\x1b[33m",
-  dim: "\x1b[2m"
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m"
 };
 
+const DEFAULT_PASSWORD = "123456";
+
+// Resolve db.json path (matches app/src/lib/dataDir.js convention)
+function getDbPath() {
+  return process.platform === "win32"
+    ? path.join(process.env.APPDATA || "", "9router", "db.json")
+    : path.join(os.homedir(), ".9router", "db.json");
+}
+
 /**
- * Show settings menu (tunnel controls)
+ * Show settings menu (tunnel + RTK + reset password)
  * @param {Array<string>} breadcrumb - Breadcrumb path
  */
 async function showSettingsMenu(breadcrumb = []) {
   await showMenuWithBack({
     title: "⚙️  Settings",
     breadcrumb,
-    headerContent: async () => {
-      const result = await api.getTunnelStatus();
-      if (!result.success) return "  Failed to load tunnel status";
-      
-      const { enabled, publicUrl, shortId } = result.data || {};
-      
-      if (enabled && publicUrl) {
-        return [
-          `  Endpoint: ${COLORS.green}${publicUrl}/v1${COLORS.reset}`,
-          `  Tunnel:   ${COLORS.green}ON${COLORS.reset} ${COLORS.dim}(${shortId})${COLORS.reset}`
-        ].join("\n");
+    headerContent: async (data) => {
+      const lines = [];
+
+      // Tunnel section
+      const tunnel = data?.tunnel || {};
+      if (tunnel.enabled && tunnel.publicUrl) {
+        lines.push(`  Endpoint: ${COLORS.green}${tunnel.publicUrl}/v1${COLORS.reset}`);
+        lines.push(`  Tunnel:   ${COLORS.green}ON${COLORS.reset} ${COLORS.dim}(${tunnel.shortId})${COLORS.reset}`);
       } else {
-        return [
-          `  Endpoint: http://localhost:20128/v1`,
-          `  Tunnel:   ${COLORS.red}OFF${COLORS.reset} ${COLORS.dim}(local only)${COLORS.reset}`
-        ].join("\n");
+        lines.push(`  Endpoint: http://localhost:20128/v1`);
+        lines.push(`  Tunnel:   ${COLORS.red}OFF${COLORS.reset} ${COLORS.dim}(local only)${COLORS.reset}`);
       }
+
+      // RTK section
+      const rtkOn = data?.settings?.rtkEnabled !== false;
+      lines.push(`  RTK:      ${rtkOn ? `${COLORS.green}ON${COLORS.reset}` : `${COLORS.red}OFF${COLORS.reset}`} ${COLORS.dim}(Token Saver)${COLORS.reset}`);
+
+      return lines.join("\n");
+    },
+    refresh: async () => {
+      const [tunnelRes, settingsRes] = await Promise.all([
+        api.getTunnelStatus(),
+        api.getSettings()
+      ]);
+      return {
+        tunnel: tunnelRes.success ? (tunnelRes.data || {}) : {},
+        settings: settingsRes.success ? (settingsRes.data || {}) : {}
+      };
     },
-    refresh: async () => ({}),
     items: [
       {
         label: "Tunnel ON",
-        action: async () => {
-          await enableTunnel();
-          return true;
-        }
+        action: async () => { await enableTunnel(); return true; }
       },
       {
         label: "Tunnel OFF",
-        action: async () => {
-          await disableTunnel();
-          return true;
-        }
+        action: async () => { await disableTunnel(); return true; }
+      },
+      {
+        label: (d) => {
+          const on = d?.settings?.rtkEnabled !== false;
+          return `Token Saver (RTK): ${on ? "ON" : "OFF"} → toggle`;
+        },
+        action: async (d) => { await toggleRtk(d?.settings?.rtkEnabled !== false); return true; }
+      },
+      {
+        label: "🔑 Reset Password to Default",
+        action: async () => { await resetPassword(); return true; }
       }
     ]
   });
@@ -64,7 +92,7 @@ async function showSettingsMenu(breadcrumb = []) {
 async function enableTunnel() {
   showStatus("Creating tunnel...", "info");
   const result = await api.enableTunnel();
-  
+
   if (result.success) {
     const { publicUrl, shortId, alreadyRunning } = result.data || {};
     if (alreadyRunning) {
@@ -75,7 +103,7 @@ async function enableTunnel() {
   } else {
     showStatus(`Failed: ${result.error}`, "error");
   }
-  
+
   await pause();
 }
 
@@ -84,13 +112,62 @@ async function enableTunnel() {
  */
 async function disableTunnel() {
   const result = await api.disableTunnel();
-  
+
   if (result.success) {
     showStatus("Tunnel disabled", "success");
   } else {
     showStatus(`Failed: ${result.error}`, "error");
   }
-  
+
+  await pause();
+}
+
+/**
+ * Toggle RTK (Token Saver) via API
+ * @param {boolean} currentlyOn
+ */
+async function toggleRtk(currentlyOn) {
+  const next = !currentlyOn;
+  const result = await api.updateSettings({ rtkEnabled: next });
+  if (result.success) {
+    showStatus(`Token Saver ${next ? "enabled" : "disabled"}`, "success");
+  } else {
+    showStatus(`Failed: ${result.error}`, "error");
+  }
+  await pause();
+}
+
+/**
+ * Reset dashboard password by clearing the hash in db.json (Phase B).
+ * After reset, user can log in with the default password "123456".
+ */
+async function resetPassword() {
+  const dbPath = getDbPath();
+
+  if (!fs.existsSync(dbPath)) {
+    showStatus(`db.json not found at ${dbPath}`, "error");
+    await pause();
+    return;
+  }
+
+  const ok = await confirm(`Reset dashboard password to default "${DEFAULT_PASSWORD}"?`);
+  if (!ok) {
+    showStatus("Cancelled", "info");
+    await pause();
+    return;
+  }
+
+  try {
+    const raw = fs.readFileSync(dbPath, "utf-8");
+    const db = JSON.parse(raw);
+    if (db.settings && Object.prototype.hasOwnProperty.call(db.settings, "password")) {
+      delete db.settings.password;
+    }
+    fs.writeFileSync(dbPath, JSON.stringify(db, null, 2));
+    showStatus(`Password reset. Default: ${DEFAULT_PASSWORD}`, "success");
+  } catch (err) {
+    showStatus(`Failed to reset password: ${err.message}`, "error");
+  }
   await pause();
 }
 

package/src/cli/utils/modelSelector.js

@@ -58,11 +58,14 @@ async function getAvailableModelsGrouped() {
  * Display model list and prompt for selection
  * @param {string} title - Title to display
  * @param {string} currentValue - Current selected value (optional)
+ * @param {Object} options - { excludeCombos?: boolean }
  * @returns {Promise<string|null>} Selected model ID or null if cancelled
  */
-async function selectModelFromList(title, currentValue = "") {
-  const { combos, groups } = await getAvailableModelsGrouped();
-  
+async function selectModelFromList(title, currentValue = "", options = {}) {
+  const { excludeCombos = false } = options;
+  const { combos: rawCombos, groups } = await getAvailableModelsGrouped();
+  const combos = excludeCombos ? [] : rawCombos;
+
   const totalModels = combos.length + Object.values(groups).flat().length;
   if (totalModels === 0) {
     return null;
@@ -83,7 +86,7 @@ async function selectModelFromList(title, currentValue = "") {
   
   let idx = 1;
   
-  // Combos first
+  // Combos first (skipped when excludeCombos is true)
   if (combos.length > 0) {
     console.log("[Combos]");
     combos.forEach(combo => {