@techysy/10router 1.2.0 → 1.3.0

package/src/cli/i18n/locales/en/utils.json

@@ -11,6 +11,10 @@
   "utils.modelSelector.combosHeader": "[Combos]",
   "utils.modelSelector.cancelOption": "  0. Cancel\n",
   "utils.modelSelector.enterNumber": "Enter number: ",
+  "utils.modelSelector.noProvidersHeader": "\n  No connected providers found.",
+  "utils.modelSelector.connectHint": "  Please connect a provider in Providers menu first.\n",
+  "utils.modelSelector.customOption": "  m. ✍️  Enter custom model ID",
+  "utils.modelSelector.enterCustom": "Enter custom model ID: ",
 
   "utils.format.invalidDate": "Invalid Date",
   "utils.format.justNow": "just now",

package/src/cli/i18n/locales/zh-CN/utils.json

@@ -11,6 +11,10 @@
   "utils.modelSelector.combosHeader": "【组合】",
   "utils.modelSelector.cancelOption": "  0. 取消\n",
   "utils.modelSelector.enterNumber": "请输入编号：",
+  "utils.modelSelector.noProvidersHeader": "\n  未发现已连接的供应商。",
+  "utils.modelSelector.connectHint": "  请先在供应商菜单中连接一个供应商。\n",
+  "utils.modelSelector.customOption": "  m. ✍️  手动输入模型 ID",
+  "utils.modelSelector.enterCustom": "请输入自定义模型 ID：",
 
   "utils.format.invalidDate": "无效日期",
   "utils.format.justNow": "刚刚",

package/src/cli/i18n/locales/zh-TW/utils.json

@@ -11,6 +11,10 @@
   "utils.modelSelector.combosHeader": "【組合】",
   "utils.modelSelector.cancelOption": "  0. 取消\n",
   "utils.modelSelector.enterNumber": "請輸入編號：",
+  "utils.modelSelector.noProvidersHeader": "\n  未發現已連接的供應商。",
+  "utils.modelSelector.connectHint": "  請先在供應商選單中連接一個供應商。\n",
+  "utils.modelSelector.customOption": "  m. ✍️  手動輸入模型 ID",
+  "utils.modelSelector.enterCustom": "請輸入自定義模型 ID：",
 
   "utils.format.invalidDate": "無效日期",
   "utils.format.justNow": "剛剛",

package/src/cli/menus/settings.js

@@ -106,7 +106,7 @@ async function showSettingsMenu(breadcrumb = []) {
 
 /**
  * Reset authMode to "password" via API. Used when OIDC is misconfigured
- * and user is locked out of dashboard. CLI bypasses auth via x-9r-cli-token.
+ * and user is locked out of dashboard. CLI bypasses auth via x-10r-cli-token.
  */
 async function resetAuthMode() {
   const ok = await confirm(t("menus.settings.resetAuthConfirm"));

package/src/cli/staleServer.js

@@ -1,216 +1,216 @@
-"use strict";
-
-/**
- * Stale-build self-heal.
- *
- * `npm i -g @techysy/10router@latest` (or an fpk / desktop update) replaces the
- * package directory on disk, but a server spawned by the *previous* version is
- * `detached` and keeps running: it still owns the port and serves an HTML shell
- * that references chunk hashes the new package no longer ships, so every chunk
- * request 500s and the dashboard goes blank (ChunkLoadError). The launcher had
- * no way to notice — it only ever spawned a server, never probed for one that
- * was already there.
- *
- * The probe is deliberately narrow: we only kill when the port *answers*
- * /api/version AND reports a version different from ours. Everything else (no
- * answer, same version, an unrelated service on the port) leaves the previous
- * behaviour untouched, so a recycled PID can never be killed on a guess.
- *
- * All process/DNS/fetch side effects are injectable so the logic is unit
- * testable without spawning or killing anything.
- */
-
-const fs = require("fs");
-const path = require("path");
-
-const DEFAULT_PROBE_TIMEOUT_MS = 2000;
-const DEFAULT_RELEASE_TIMEOUT_MS = 5000;
-const RELEASE_POLL_INTERVAL_MS = 150;
-
-function pidFilePath(dataDir) {
-  return path.join(dataDir, "server.pid");
-}
-
-function diskVersionPath(dataDir) {
-  return path.join(dataDir, ".disk-version");
-}
-
-function readPidFile(dataDir) {
-  try {
-    const pid = parseInt(fs.readFileSync(pidFilePath(dataDir), "utf8").trim(), 10);
-    return Number.isInteger(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
-}
-
-function writePidFile(dataDir, pid) {
-  try {
-    fs.mkdirSync(dataDir, { recursive: true });
-    fs.writeFileSync(pidFilePath(dataDir), String(pid), "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function removePidFile(dataDir) {
-  try {
-    fs.unlinkSync(pidFilePath(dataDir));
-  } catch {
-    /* already gone / never written */
-  }
-}
-
-// The version the package directory currently holds. Written on install and on
-// every launcher start, so a still-running OLD server can report "the disk has
-// moved on" even though it cannot read the new package's code.
-function writeDiskVersion(dataDir, version) {
-  try {
-    fs.mkdirSync(dataDir, { recursive: true });
-    fs.writeFileSync(diskVersionPath(dataDir), String(version), "utf8");
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function readDiskVersion(dataDir) {
-  try {
-    const v = fs.readFileSync(diskVersionPath(dataDir), "utf8").trim();
-    return v || null;
-  } catch {
-    return null;
-  }
-}
-
-// Inequality only — never an ordering. `1.1.1` vs `1.1.2` and `1.1.2` vs
-// `1.1.2-test.3` are both "disk moved on", and `1.1.2-test.3` vs `1.1.2` is not
-// (a test build of the same release must not look stale against itself).
-function isVersionMismatch(runningVersion, diskVersion) {
-  if (!runningVersion || !diskVersion) return false;
-  return String(runningVersion) !== String(diskVersion);
-}
-
-/**
- * Probe http://127.0.0.1:<port>/api/version.
- * @returns {Promise<{reachable: boolean, version: string|null}>}
- *   reachable=false → nothing is listening (normal cold start).
- *   reachable=true, version=null → something is there but not our server / no JSON.
- */
-async function probeServerVersion(port, { fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS } = {}) {
-  if (typeof fetchImpl !== "function") return { reachable: false, version: null };
-  const controller = typeof AbortController === "function" ? new AbortController() : null;
-  const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
-  try {
-    const res = await fetchImpl(`http://127.0.0.1:${port}/api/version`, {
-      signal: controller ? controller.signal : undefined,
-      cache: "no-store",
-    });
-    if (!res || !res.ok) return { reachable: true, version: null };
-    const data = await res.json();
-    return { reachable: true, version: data && data.currentVersion ? String(data.currentVersion) : null };
-  } catch {
-    return { reachable: false, version: null };
-  } finally {
-    if (timer) clearTimeout(timer);
-  }
-}
-
-/** Kill a pid. POSIX uses SIGKILL on the group leader; win32 taskkills the tree. */
-function killPid(pid, { platform = process.platform, killImpl, taskkillImpl } = {}) {
-  if (!pid) return false;
-  try {
-    if (platform === "win32") {
-      const run =
-        taskkillImpl ||
-        ((p) => require("child_process").spawnSync("taskkill", ["/PID", String(p), "/F", "/T"], {
-          stdio: "ignore",
-          windowsHide: true,
-          timeout: 5000,
-        }));
-      run(pid);
-      return true;
-    }
-    const kill = killImpl || ((p) => process.kill(p, "SIGKILL"));
-    kill(pid);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Poll until nothing answers on the port (or timeout). */
-async function waitForPortRelease(port, options = {}) {
-  const {
-    timeoutMs = DEFAULT_RELEASE_TIMEOUT_MS,
-    intervalMs = RELEASE_POLL_INTERVAL_MS,
-    probe = probeServerVersion,
-  } = options;
-  const deadline = Date.now() + timeoutMs;
-  for (;;) {
-    const { reachable } = await probe(port, options.probeOptions || {});
-    if (!reachable) return true;
-    if (Date.now() >= deadline) return false;
-    await new Promise((r) => setTimeout(r, intervalMs));
-  }
-}
-
-/**
- * Detect and clear a server left over from a different build.
- *
- * @returns {Promise<{action: "none"|"warn"|"killed", reason: string, running?: string, pid?: number|null}>}
- */
-async function healStaleServer({
-  port,
-  version,
-  dataDir,
-  log: _log = () => {},
-  fetchImpl,
-  probeTimeoutMs,
-  releaseTimeoutMs,
-  platform,
-  killImpl,
-  taskkillImpl,
-} = {}) {
-  const probeOptions = { fetchImpl, timeoutMs: probeTimeoutMs };
-  const probe = await probeServerVersion(port, probeOptions);
-
-  if (!probe.reachable) return { action: "none", reason: "unreachable" };
-  if (!probe.version) return { action: "none", reason: "no-version" };
-  // Same build ⇒ this is our own server on a re-run; leave it alone (the
-  // previous behaviour on an occupied port is preserved).
-  if (!isVersionMismatch(probe.version, version)) return { action: "none", reason: "same-version" };
-
-  const pid = readPidFile(dataDir);
-  if (!pid) {
-    // Proved it is our server (it answered /api/version) but we have no pid to
-    // kill safely — a version that predates the pidfile. Report and carry on.
-    return { action: "warn", reason: "stale-without-pidfile", running: probe.version, pid: null };
-  }
-
-  killPid(pid, { platform, killImpl, taskkillImpl });
-  removePidFile(dataDir);
-  await waitForPortRelease(port, {
-    timeoutMs: releaseTimeoutMs,
-    probeOptions,
-    probe: (p, o) => probeServerVersion(p, o || {}),
-  });
-
-  return { action: "killed", reason: "stale-killed", running: probe.version, pid };
-}
-
-module.exports = {
-  healStaleServer,
-  isVersionMismatch,
-  killPid,
-  pidFilePath,
-  diskVersionPath,
-  probeServerVersion,
-  readDiskVersion,
-  readPidFile,
-  removePidFile,
-  waitForPortRelease,
-  writeDiskVersion,
-  writePidFile,
-};
+"use strict";
+
+/**
+ * Stale-build self-heal.
+ *
+ * `npm i -g @techysy/10router@latest` (or an fpk / desktop update) replaces the
+ * package directory on disk, but a server spawned by the *previous* version is
+ * `detached` and keeps running: it still owns the port and serves an HTML shell
+ * that references chunk hashes the new package no longer ships, so every chunk
+ * request 500s and the dashboard goes blank (ChunkLoadError). The launcher had
+ * no way to notice — it only ever spawned a server, never probed for one that
+ * was already there.
+ *
+ * The probe is deliberately narrow: we only kill when the port *answers*
+ * /api/version AND reports a version different from ours. Everything else (no
+ * answer, same version, an unrelated service on the port) leaves the previous
+ * behaviour untouched, so a recycled PID can never be killed on a guess.
+ *
+ * All process/DNS/fetch side effects are injectable so the logic is unit
+ * testable without spawning or killing anything.
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+const DEFAULT_PROBE_TIMEOUT_MS = 2000;
+const DEFAULT_RELEASE_TIMEOUT_MS = 5000;
+const RELEASE_POLL_INTERVAL_MS = 150;
+
+function pidFilePath(dataDir) {
+  return path.join(dataDir, "server.pid");
+}
+
+function diskVersionPath(dataDir) {
+  return path.join(dataDir, ".disk-version");
+}
+
+function readPidFile(dataDir) {
+  try {
+    const pid = parseInt(fs.readFileSync(pidFilePath(dataDir), "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function writePidFile(dataDir, pid) {
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(pidFilePath(dataDir), String(pid), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function removePidFile(dataDir) {
+  try {
+    fs.unlinkSync(pidFilePath(dataDir));
+  } catch {
+    /* already gone / never written */
+  }
+}
+
+// The version the package directory currently holds. Written on install and on
+// every launcher start, so a still-running OLD server can report "the disk has
+// moved on" even though it cannot read the new package's code.
+function writeDiskVersion(dataDir, version) {
+  try {
+    fs.mkdirSync(dataDir, { recursive: true });
+    fs.writeFileSync(diskVersionPath(dataDir), String(version), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function readDiskVersion(dataDir) {
+  try {
+    const v = fs.readFileSync(diskVersionPath(dataDir), "utf8").trim();
+    return v || null;
+  } catch {
+    return null;
+  }
+}
+
+// Inequality only — never an ordering. `1.1.1` vs `1.1.2` and `1.1.2` vs
+// `1.1.2-test.3` are both "disk moved on", and `1.1.2-test.3` vs `1.1.2` is not
+// (a test build of the same release must not look stale against itself).
+function isVersionMismatch(runningVersion, diskVersion) {
+  if (!runningVersion || !diskVersion) return false;
+  return String(runningVersion) !== String(diskVersion);
+}
+
+/**
+ * Probe http://127.0.0.1:<port>/api/version.
+ * @returns {Promise<{reachable: boolean, version: string|null}>}
+ *   reachable=false → nothing is listening (normal cold start).
+ *   reachable=true, version=null → something is there but not our server / no JSON.
+ */
+async function probeServerVersion(port, { fetchImpl = globalThis.fetch, timeoutMs = DEFAULT_PROBE_TIMEOUT_MS } = {}) {
+  if (typeof fetchImpl !== "function") return { reachable: false, version: null };
+  const controller = typeof AbortController === "function" ? new AbortController() : null;
+  const timer = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+  try {
+    const res = await fetchImpl(`http://127.0.0.1:${port}/api/version`, {
+      signal: controller ? controller.signal : undefined,
+      cache: "no-store",
+    });
+    if (!res || !res.ok) return { reachable: true, version: null };
+    const data = await res.json();
+    return { reachable: true, version: data && data.currentVersion ? String(data.currentVersion) : null };
+  } catch {
+    return { reachable: false, version: null };
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
+/** Kill a pid. POSIX uses SIGKILL on the group leader; win32 taskkills the tree. */
+function killPid(pid, { platform = process.platform, killImpl, taskkillImpl } = {}) {
+  if (!pid) return false;
+  try {
+    if (platform === "win32") {
+      const run =
+        taskkillImpl ||
+        ((p) => require("child_process").spawnSync("taskkill", ["/PID", String(p), "/F", "/T"], {
+          stdio: "ignore",
+          windowsHide: true,
+          timeout: 5000,
+        }));
+      run(pid);
+      return true;
+    }
+    const kill = killImpl || ((p) => process.kill(p, "SIGKILL"));
+    kill(pid);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Poll until nothing answers on the port (or timeout). */
+async function waitForPortRelease(port, options = {}) {
+  const {
+    timeoutMs = DEFAULT_RELEASE_TIMEOUT_MS,
+    intervalMs = RELEASE_POLL_INTERVAL_MS,
+    probe = probeServerVersion,
+  } = options;
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    const { reachable } = await probe(port, options.probeOptions || {});
+    if (!reachable) return true;
+    if (Date.now() >= deadline) return false;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+}
+
+/**
+ * Detect and clear a server left over from a different build.
+ *
+ * @returns {Promise<{action: "none"|"warn"|"killed", reason: string, running?: string, pid?: number|null}>}
+ */
+async function healStaleServer({
+  port,
+  version,
+  dataDir,
+  log: _log = () => {},
+  fetchImpl,
+  probeTimeoutMs,
+  releaseTimeoutMs,
+  platform,
+  killImpl,
+  taskkillImpl,
+} = {}) {
+  const probeOptions = { fetchImpl, timeoutMs: probeTimeoutMs };
+  const probe = await probeServerVersion(port, probeOptions);
+
+  if (!probe.reachable) return { action: "none", reason: "unreachable" };
+  if (!probe.version) return { action: "none", reason: "no-version" };
+  // Same build ⇒ this is our own server on a re-run; leave it alone (the
+  // previous behaviour on an occupied port is preserved).
+  if (!isVersionMismatch(probe.version, version)) return { action: "none", reason: "same-version" };
+
+  const pid = readPidFile(dataDir);
+  if (!pid) {
+    // Proved it is our server (it answered /api/version) but we have no pid to
+    // kill safely — a version that predates the pidfile. Report and carry on.
+    return { action: "warn", reason: "stale-without-pidfile", running: probe.version, pid: null };
+  }
+
+  killPid(pid, { platform, killImpl, taskkillImpl });
+  removePidFile(dataDir);
+  await waitForPortRelease(port, {
+    timeoutMs: releaseTimeoutMs,
+    probeOptions,
+    probe: (p, o) => probeServerVersion(p, o || {}),
+  });
+
+  return { action: "killed", reason: "stale-killed", running: probe.version, pid };
+}
+
+module.exports = {
+  healStaleServer,
+  isVersionMismatch,
+  killPid,
+  pidFilePath,
+  diskVersionPath,
+  probeServerVersion,
+  readDiskVersion,
+  readPidFile,
+  removePidFile,
+  waitForPortRelease,
+  writeDiskVersion,
+  writePidFile,
+};

package/src/cli/utils/modelSelector.js

@@ -3,22 +3,24 @@ const { t } = require("../i18n");
 const { prompt } = require("./input");
 const { clearScreen } = require("./display");
 
-// Provider alias order: OAuth first, then API Key (matches ModelSelectModal)
+// Provider alias order: OAuth first, then Free, then API Key (matches ModelSelectModal)
 const PROVIDER_ALIAS_ORDER = [
-  "cc", "ag", "cx", "if", "qw", "gc", "gh", "kr",
+  "cc", "ag", "cx", "if", "qw", "gc", "gh", "kr", "oc",
   "openrouter", "glm", "kimi", "minimax", "openai", "anthropic", "gemini"
 ];
 
 // Alias to display name mapping
 const PROVIDER_ALIAS_NAMES = {
   cc: "Claude Code",
-  ag: "Antigravity", 
+  ag: "Antigravity",
   cx: "OpenAI Codex",
   if: "iFlow AI",
   qw: "Qwen Code",
   gc: "Gemini CLI",
   gh: "GitHub Copilot",
   kr: "Kiro AI",
+  oc: "OpenCode Free",
+  opencode: "OpenCode Free",
   openrouter: "OpenRouter",
   glm: "GLM Coding",
   kimi: "Kimi Coding",
@@ -28,30 +30,81 @@ const PROVIDER_ALIAS_NAMES = {
   gemini: "Gemini"
 };
 
+const PROVIDER_ID_TO_ALIAS = {
+  claude: "cc",
+  codex: "cx",
+  "gemini-cli": "gc",
+  github: "gh",
+  antigravity: "ag",
+  iflow: "if",
+  qwen: "qw",
+  kiro: "kr",
+  cursor: "cu",
+  cline: "cline",
+  clinepass: "clinepass",
+  qoder: "qd",
+  "qoder-cn": "qd",
+  gitlab: "gitlab",
+  "codebuddy-cn": "cb",
+  "codebuddy-intl": "cbai",
+  kimchi: "kimchi",
+  "grok-cli": "grok-cli",
+  trae: "trae",
+  windsurf: "windsurf",
+  zed: "zed",
+  opencode: "oc",
+  "opencode-go": "ocg",
+  "opencode-zen": "ocz",
+};
+
+// Providers usable without stored credentials
+const NO_AUTH_PROVIDERS = new Set(["opencode", "oc"]);
+
 /**
- * Get all available models grouped by provider + combos
+ * Get available models grouped by provider + combos, filtered to providers
+ * that actually have an active connection (plus noAuth providers). The /v1
+ * models endpoint lists the whole catalog; without this filter the selector
+ * offered providers the user never connected.
  * @returns {Promise<{combos: Array, groups: Object}>}
  */
 async function getAvailableModelsGrouped() {
-  const result = await api.getAvailableModels();
-  if (!result.success) return { combos: [], groups: {} };
-  
-  const models = result.data?.data || [];
+  const [modelsResult, providersResult] = await Promise.all([
+    api.getAvailableModels(),
+    api.getProviders()
+  ]);
+
+  if (!modelsResult.success) return { combos: [], groups: {} };
+
+  const connections = providersResult.success ? (providersResult.data?.connections || []) : [];
+  const activeAliases = new Set(NO_AUTH_PROVIDERS);
+
+  connections.forEach(conn => {
+    if (conn.isActive === false) return;
+    const p = conn.provider || conn.providerId;
+    if (!p) return;
+    activeAliases.add(p);
+    const alias = conn.providerSpecificData?.prefix || PROVIDER_ID_TO_ALIAS[p] || p;
+    activeAliases.add(alias);
+  });
+
+  const models = modelsResult.data?.data || [];
   const combos = [];
   const groups = {};
-  
+
   models.forEach(m => {
     if (m.owned_by === "combo") {
       combos.push(m.id);
     } else {
       const provider = m.owned_by;
+      // Only keep connected providers or noAuth providers
+      if (!activeAliases.has(provider)) return;
       if (!groups[provider]) {
         groups[provider] = [];
       }
       groups[provider].push(m.id);
     }
   });
-  
+
   return { combos, groups };
 }
 
@@ -69,6 +122,19 @@ async function selectModelFromList(title, currentValue = "", options = {}) {
 
   const totalModels = combos.length + Object.values(groups).flat().length;
   if (totalModels === 0) {
+    clearScreen();
+    console.log(`\n🎯 ${title}`);
+    console.log("=".repeat(50));
+    console.log(t("utils.modelSelector.noProvidersHeader"));
+    console.log(t("utils.modelSelector.connectHint"));
+    console.log(t("utils.modelSelector.customOption"));
+    console.log(t("utils.modelSelector.cancelOption"));
+    const act = await prompt(t("utils.modelSelector.enterNumber"));
+    const trimmed = act.trim();
+    if (trimmed.toLowerCase() === "m") {
+      const custom = await prompt(t("utils.modelSelector.enterCustom"));
+      return custom.trim() || null;
+    }
     return null;
   }