free-coding-models 0.5.87 → 0.5.89

package/src/core/security.js

@@ -17,21 +17,34 @@
  *    Now checkConfigSecurity() is async, awaited by the bin entry BEFORE the TUI
  *    starts, and it never prompts on non-TTY stdin or daemon/web/JSON surfaces.
  *
- * 📖 Secure permissions:
- *    - 0o600 (octal 600) = user:rw, group:---, world:---
- *    - Only the file owner can read or write
- *    - This is the standard for files containing secrets (SSH keys, API keys, etc.)
+ * 📖 Issue #173 follow-up (rutexd): on Windows the "fix" never persisted and the
+ *    warning re-fired on every launch. Root cause: Node maps win32 modes to only
+ *    0666 (writable) or 0444 (read-only), so 0600 is unreachable and
+ *    `(mode & 0o777) === 0o600` was always false; chmod 600 on win32 just clears
+ *    the read-only bit. The real fix:
+ *    - the Windows verdict now comes from the NTFS ACL via `icacls <file>`
+ *    - fixing on Windows runs `icacls /inheritance:r /grant:r <user>:F` and is
+ *      verified by re-reading the ACL before claiming success
+ *    - when the fix cannot be applied or verified, an ack marker file
+ *      (<config>.securityack) keeps the warning quiet for 30 days instead of
+ *      nagging on every launch (--fix-permissions bypasses the marker)
+ *    POSIX behaviour (chmod 600) is unchanged on macOS/Linux.
  *
- * 📖 Windows note: Node's chmod on win32 is best-effort (it can only toggle the
- *    read-only attribute, NTFS ACLs still govern real access). We still try,
- *    and the manual hint points at icacls for a real fix.
+ * 📖 Secure permissions:
+ *    - POSIX: 0o600 (octal 600) = user:rw, group:---, world:---
+ *    - Windows: NTFS inheritance disabled, grants only for the current user
+ *      (SYSTEM/Administrators whitelisted) - see parseIcaclsOutput in utils.js
  *
  * @functions
  *   → checkConfigSecurity() - Async main security check; awaited before the TUI starts
  *   → resolveSecurityAction() - Pure gate deciding auto-fix / prompt / warn-only (in utils.js)
+ *   → parseIcaclsOutput() - Pure parser for icacls output (in utils.js)
+ *   → shouldSkipSecurityWarn() - Pure anti-nag gate for repeat warnings (in utils.js)
  *   → getConfigPermissions() - Returns file mode object for config
- *   → isConfigSecure() - Boolean check if permissions are correct
- *   → fixConfigPermissions() - Applies chmod 600 to config file (best-effort on Windows)
+ *   → isConfigSecure() - Boolean check if permissions are correct (POSIX modes)
+ *   → fixConfigPermissions() - Applies chmod 600 to config file (POSIX)
+ *   → getWindowsAclStatus() - Async icacls read + parse → is the ACL secure?
+ *   → fixWindowsAcl() - Async icacls fix + ACL re-verify
  *   → promptSecurityFix() - Interactive prompt asking user to fix permissions
  *
  * @exports checkConfigSecurity, isConfigSecure, fixConfigPermissions, formatMode, formatModeRwx
@@ -41,8 +54,12 @@ import fs from 'node:fs'
 import path from 'node:path'
 import os from 'node:os'
 import readline from 'node:readline'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 import { CONFIG_PATH } from './config.js'
-import { resolveSecurityAction } from './utils.js'
+import { resolveSecurityAction, parseIcaclsOutput, shouldSkipSecurityWarn } from './utils.js'
+
+const execFileAsync = promisify(execFile)
 
 // 📖 Config file path - matches the path used in config.js (honours the
 // 📖 --config-dir / FCM_CONFIG_DIR override when set).
@@ -91,7 +108,8 @@ export function isConfigSecure() {
 }
 
 // 📖 Fix config file permissions to secure mode (chmod 600)
-// 📖 Best-effort on Windows (read-only bit); returns true if successful, false otherwise
+// 📖 POSIX path; on Windows this is NOT the real fix (see fixWindowsAcl) and is
+// 📖 kept only as a harmless last-ditch fallback. Returns true if successful.
 export function fixConfigPermissions() {
   const configPath = getConfigPath()
 
@@ -107,6 +125,88 @@ export function fixConfigPermissions() {
   }
 }
 
+// 📖 Current Windows user name, used both for icacls grants and for matching
+// 📖 ACE lines when parsing the ACL (os.userInfo works on win32 too).
+function getWindowsUserName() {
+  try {
+    return os.userInfo().username
+  } catch {
+    return process.env.USERNAME || ''
+  }
+}
+
+// 📖 Read the real NTFS ACL via icacls and decide if it is secure:
+// 📖 inheritance disabled + grants only for the current user (and trusted
+// 📖 SYSTEM/Administrators entries). Returns { checked, secure, ...parsed };
+// 📖 checked=false when icacls is missing or failed (caller falls back to the
+// 📖 ack-gated warning path instead of trusting useless mode bits).
+async function getWindowsAclStatus(configPath) {
+  try {
+    const { stdout } = await execFileAsync('icacls', [configPath], {
+      timeout: 5000,
+      windowsHide: true,
+    })
+    const parsed = parseIcaclsOutput({ output: stdout, userName: getWindowsUserName(), filePath: configPath })
+    const secure = !parsed.inheritanceEnabled && !parsed.othersHaveAccess && parsed.ownerHasAccess
+    return { checked: true, secure, ...parsed }
+  } catch (err) {
+    return { checked: false, secure: false, grants: [], otherNames: [] }
+  }
+}
+
+// 📖 Fix the NTFS ACL for real: drop inherited ACEs, grant only the current
+// 📖 user full control, then VERIFY by re-reading the ACL (never claim success
+// 📖 without proof - that lie was the core of the issue #173 follow-up).
+// 📖 execFile (no shell) keeps the path injection-safe even with spaces.
+async function fixWindowsAcl(configPath) {
+  const userName = getWindowsUserName()
+  if (!userName) return false
+
+  try {
+    await execFileAsync(
+      'icacls',
+      [configPath, '/inheritance:r', '/grant:r', `${userName}:F`],
+      { timeout: 5000, windowsHide: true }
+    )
+    const status = await getWindowsAclStatus(configPath)
+    return status.checked && status.secure
+  } catch (err) {
+    return false
+  }
+}
+
+// 📖 Anti-nag marker: written when we warned but could not fix/verify, so the
+// 📖 same warning does not re-fire on every launch (see shouldSkipSecurityWarn).
+// 📖 Lives next to the config so --config-dir / FCM_CONFIG_DIR stays coherent.
+function getAckPath() {
+  return `${getConfigPath()}.securityack`
+}
+
+function readSecurityAck() {
+  try {
+    return fs.readFileSync(getAckPath(), 'utf8').trim()
+  } catch {
+    return null
+  }
+}
+
+function writeSecurityAck() {
+  try {
+    fs.writeFileSync(getAckPath(), new Date().toISOString(), { mode: 0o600 })
+    return true
+  } catch {
+    return false
+  }
+}
+
+function clearSecurityAck() {
+  try {
+    fs.unlinkSync(getAckPath())
+  } catch {
+    // 📖 Nothing to clean up is fine.
+  }
+}
+
 // 📖 Format permission mode in octal (e.g., 0o644 → "644")
 // 📖 Exported for unit tests
 export function formatMode(mode) {
@@ -133,7 +233,9 @@ export function formatModeRwx(mode) {
 }
 
 // 📖 Print the insecure-permissions warning (stderr, so --json stdout stays clean)
-function printSecurityWarning(perms) {
+// 📖 On Windows, mode bits are meaningless (always 0666/0444), so when the ACL
+// 📖 was read we show WHAT actually grants access instead of a fake octal story.
+function printSecurityWarning(perms, aclStatus = { checked: false }) {
   const currentMode = formatMode(perms.mode)
   const currentRwx = formatModeRwx(perms.mode)
 
@@ -145,16 +247,29 @@ function printSecurityWarning(perms) {
   console.error('')
   console.error('This means other users on this system may be able to read your API keys.')
   console.error('')
-  console.error('Recommended: Fix permissions to 600 (rw-------) - owner read/write only')
+
+  if (aclStatus.checked) {
+    if (aclStatus.inheritanceEnabled) {
+      console.error('NTFS: this file inherits access permissions from your user folder.')
+    }
+    if (aclStatus.othersHaveAccess) {
+      const names = (aclStatus.otherNames || []).slice(0, 3).join(', ')
+      console.error(`NTFS: access is also granted to: ${names}`)
+    }
+    console.error('')
+  }
+
+  console.error('Recommended: restrict access to your user account only')
 }
 
-// 📖 Print the manual fix hint. On Windows, point at icacls since Node's chmod
-// 📖 only toggles the read-only attribute there.
+// 📖 Print the manual fix hint. Platform-matched command: icacls on Windows
+// 📖 (NTFS ACLs), chmod elsewhere.
 function printManualFixHint() {
   console.error('')
   if (IS_WINDOWS) {
+    const user = getWindowsUserName() || '$env:USERNAME'
     console.error('To fix manually (PowerShell), run:')
-    console.error(`  icacls "${getConfigPath()}" /inheritance:r /grant:r "$env:USERNAME:R,W"`)
+    console.error(`  icacls "${getConfigPath()}" /inheritance:r /grant:r "${user}:F"`)
   } else {
     console.error('To fix manually, run:')
     console.error(`  chmod 600 ${getConfigPath()}`)
@@ -164,24 +279,37 @@ function printManualFixHint() {
 
 // 📖 Apply the fix and report the outcome. Shared by the prompt path (user said
 // 📖 yes) and the auto-fix path (--fix-permissions / --yes / -y).
-function applyFixAndReport() {
-  const success = fixConfigPermissions()
+// 📖 Windows: icacls ACL fix, verified by re-reading the ACL.
+// 📖 POSIX: chmod 600, verified by re-statting the file.
+// 📖 If the fix cannot be verified, write the anti-nag ack so the warning does
+// 📖 not re-fire on every launch, and point at the manual command.
+async function applyFixAndReport() {
+  const configPath = getConfigPath()
+  let success = false
+
+  if (IS_WINDOWS) {
+    success = await fixWindowsAcl(configPath)
+  } else {
+    success = fixConfigPermissions() && getConfigPermissions()?.isSecure === true
+  }
 
   if (success) {
+    clearSecurityAck()
     console.error('')
     console.error('✅ Permissions fixed! Your API keys are now secure.')
     console.error('')
     if (IS_WINDOWS) {
-      console.error('Note: on Windows this is best-effort (read-only bit). See docs for NTFS ACLs.')
+      console.error(`NTFS access is now restricted to "${getWindowsUserName()}".`)
       console.error('')
     }
     return { wasSecure: false, wasFixed: true }
   }
 
+  writeSecurityAck()
   console.error('')
   console.error('❌ Failed to fix permissions automatically.')
   printManualFixHint()
-  return { wasSecure: false, wasFixed: false, error: 'chmod_failed' }
+  return { wasSecure: false, wasFixed: false, error: 'fix_failed' }
 }
 
 // 📖 Check security and handle the fix flow if needed
@@ -189,9 +317,14 @@ function applyFixAndReport() {
 // 📖 the confirmation prompt are visible and fully resolved before raw mode /
 // 📖 the alternate screen take over.
 //
+// 📖 Windows verdict (issue #173 follow-up): mode bits on win32 are only ever
+// 📖 0666 or 0444, so the POSIX 0600 check would nag forever. The real verdict
+// 📖 comes from the NTFS ACL (icacls). If icacls is unavailable, fall through to
+// 📖 the warning path but let the anti-nag ack keep it to once per 30 days.
+//
 // 📖 Options:
 //   autoFix       - true when --fix-permissions / --yes / -y was passed: apply the
-//                   fix without asking
+//                   fix without asking (also bypasses the anti-nag ack)
 //   promptAllowed - false on daemon/web/JSON surfaces: never prompt there, at most
 //                   warn on stderr
 //   stdinIsTTY    - override the stdin TTY detection (tests); defaults to real detection
@@ -205,11 +338,23 @@ export async function checkConfigSecurity(options = {}) {
     return { wasSecure: true, wasFixed: false }
   }
 
-  // 📖 Permissions are already secure
-  if (perms.isSecure) {
+  // 📖 Security verdict, platform-aware.
+  let aclStatus = { checked: false, secure: false, grants: [], otherNames: [] }
+  if (IS_WINDOWS) {
+    aclStatus = await getWindowsAclStatus(perms.path)
+    if (aclStatus.checked && aclStatus.secure) {
+      return { wasSecure: true, wasFixed: false }
+    }
+  } else if (perms.isSecure) {
     return { wasSecure: true, wasFixed: false }
   }
 
+  // 📖 Anti-nag gate: if we already warned recently and the fix did not stick,
+  // 📖 stay quiet instead of nagging on every launch. --fix-permissions bypasses.
+  if (options.autoFix !== true && shouldSkipSecurityWarn({ ackedAt: readSecurityAck() })) {
+    return { wasSecure: false, wasFixed: false, error: 'warned_recently' }
+  }
+
   // 📖 Pure gate (see utils.js): decides auto-fix vs prompt vs warn-only.
   const action = resolveSecurityAction({
     configExists: true,
@@ -225,7 +370,7 @@ export async function checkConfigSecurity(options = {}) {
 
   // 📖 Security issue detected! Print the warning first so it is on screen
   // 📖 no matter which path follows.
-  printSecurityWarning(perms)
+  printSecurityWarning(perms, aclStatus)
 
   if (action === 'auto-fix') {
     return applyFixAndReport()
@@ -234,6 +379,7 @@ export async function checkConfigSecurity(options = {}) {
   if (action === 'warn-only') {
     console.error('Running non-interactively (piped stdin or daemon/web mode), so skipping the prompt.')
     printManualFixHint()
+    writeSecurityAck()
     return { wasSecure: false, wasFixed: false, error: 'non_interactive' }
   }
 

package/src/core/utils.js

@@ -608,6 +608,13 @@ export function parseArgs(argv) {
   const daemonBackgroundMode = flags.includes('--daemon-bg')
   const daemonStopMode = flags.includes('--daemon-stop')
   const daemonStatusMode = flags.includes('--daemon-status')
+  // 📖 Router v2 (beta) lifecycle flags - run v2 alongside v1 on its own
+  // port (19380) with persisted breakers + decision traces. See
+  // src/core/router-v2/daemon.js and docs/router-v2.md.
+  const routerV2Mode = flags.includes('--router-v2')
+  const routerV2BackgroundMode = flags.includes('--router-v2-bg')
+  const routerV2StopMode = flags.includes('--router-v2-stop')
+  const routerV2StatusMode = flags.includes('--router-v2-status')
 
   // 📖 --fix-permissions / --yes / -y - auto-answer "yes" to the config-permission
   // 📖 security prompt (chmod 600, best-effort on Windows) so scripts, CI and
@@ -706,6 +713,11 @@ export function parseArgs(argv) {
     checkDriftMode,
     driftThreshold,
     daemonStatusMode,
+    // 📖 Router v2 (beta) lifecycle flags - see src/core/router-v2/daemon.js
+    routerV2Mode,
+    routerV2BackgroundMode,
+    routerV2StopMode,
+    routerV2StatusMode,
     // 📖 Profile system removed - API keys now persist permanently across all sessions
     recommendMode,
     devMode,
@@ -750,6 +762,103 @@ export function resolveSecurityAction({ configExists, isSecure, autoFixRequested
   return 'prompt'
 }
 
+// 📖 parseIcaclsOutput: PURE parser for Windows `icacls <file>` output, used by
+// 📖 the config security check to get a REAL answer about NTFS access.
+// 📖 WHY: on win32 Node reports POSIX-style modes as 0666 (writable) or 0444
+// 📖 (read-only) only - 0600 is unreachable - so the old `(mode & 0o777) === 0o600`
+// 📖 test was always false and the warning re-fired on every launch (issue #173
+// 📖 follow-up from rutexd). Only the ACL tells the truth on NTFS.
+// 📖
+// 📖 Sample output we must handle (ACEs, one per line, path on the first line):
+//   C:\Users\rutex\.free-coding-models.json NT AUTHORITY\SYSTEM:(I)(F)
+//                                           BUILTIN\Administrators:(I)(F)
+//                                           DESKTOP-XYZ\rutex:(F)
+//   Successfully processed 1 files; Failed processing 0 files
+// 📖 `(I)` marks an inherited ACE, so "inheritance disabled" = no `(I)` anywhere.
+// 📖 Locale-proof whitelists: names are machine-localized, so we whitelist by
+// 📖 substring (SYSTEM, Administra* covers Administrators/Administrateurs) and
+// 📖 by well-known SID (S-1-5-18 = SYSTEM, S-1-5-32-544 = Administrators), plus
+// 📖 the current user (case-insensitive, domain-qualified or bare).
+// 📖
+// 📖 Params:
+//   output   - raw stdout of `icacls <path>` (string)
+//   userName - current user name (string), e.g. "rutex"
+//   filePath - the exact path passed to icacls (optional but STRONGLY
+//              recommended: icacls echoes it on the first line, glued to the
+//              first ACE, and paths/account names can both contain spaces)
+// 📖 Returns { inheritanceEnabled, othersHaveAccess, ownerHasAccess, grants }
+//   grants = [{ name, flags }] for every ACE line; empty when output unparseable.
+export function parseIcaclsOutput({ output, userName, filePath = '' }) {
+  const text = String(output ?? '')
+  const user = String(userName ?? '').trim().toLowerCase()
+  const knownPath = String(filePath ?? '')
+  const lines = text.split(/\r?\n/)
+
+  // 📖 The rights/flags groups always end the line: "(I)(F)", "(F)", "(R,W)"...
+  const aceTail = /((?:\([^)]*\)\s*)+)$/
+  const grants = []
+  for (const rawLine of lines) {
+    const tail = aceTail.exec(rawLine)
+    if (!tail) continue
+
+    let before = rawLine.slice(0, tail.index).trim()
+    if (before === '') continue
+    // 📖 Drop the colon that separates the account name from its flags.
+    before = before.replace(/:$/, '').trim()
+    // 📖 First ACE shares its line with the echoed path: strip the path we
+    // 📖 passed to icacls. Without a known path, keep only the segment after
+    // 📖 the last whitespace (exact for simple names; callers should pass
+    // 📖 filePath when the path or account name contains spaces).
+    if (knownPath && before.startsWith(knownPath)) {
+      before = before.slice(knownPath.length).trim()
+    } else if (knownPath === '' && /\s/.test(before)) {
+      before = before.slice(before.lastIndexOf(' ') + 1).trim()
+    }
+    if (before === '') continue
+    grants.push({ name: before, flags: tail[1].replace(/\s+/g, '') })
+  }
+
+  const isTrusted = (name) => {
+    const n = name.toLowerCase()
+    if (user !== '' && (n === user || n.endsWith('\\' + user))) return true
+    if (n.includes('system') || n.includes('s-1-5-18')) return true
+    if (n.includes('administra') || n.includes('s-1-5-32-544')) return true
+    return false
+  }
+
+  const inheritanceEnabled = grants.some((g) => g.flags.includes('I'))
+  const others = grants.filter((g) => !isTrusted(g.name)).map((g) => g.name)
+  const ownerHasAccess = grants.some((g) => {
+    const n = g.name.toLowerCase()
+    return user !== '' && (n === user || n.endsWith('\\' + user))
+  })
+
+  return {
+    inheritanceEnabled,
+    othersHaveAccess: others.length > 0,
+    ownerHasAccess,
+    grants,
+    otherNames: others,
+  }
+}
+
+// 📖 shouldSkipSecurityWarn: PURE anti-nag gate for the config security warning.
+// 📖 WHY: when the permission fix cannot be applied or verified (rare: icacls
+// 📖 missing on Windows, chmod failing on POSIX), the insecure state persists and
+// 📖 the warning used to re-fire on every single launch. Once we warned and the
+// 📖 fix did not stick, stay quiet for `intervalDays` (default 30) instead of
+// 📖 nagging daily. `--fix-permissions` bypasses the gate in the caller.
+// 📖 Params: ackedAt - last warning timestamp (ms epoch or ISO string or null)
+//           now - current time in ms epoch; intervalDays - quiet window length
+// 📖 Returns true only when ackedAt parses AND is less than intervalDays old.
+export function shouldSkipSecurityWarn({ ackedAt, now = Date.now(), intervalDays = 30 }) {
+  if (ackedAt === null || ackedAt === undefined || ackedAt === '') return false
+  const then = typeof ackedAt === 'number' ? ackedAt : Date.parse(String(ackedAt))
+  if (!Number.isFinite(then)) return false
+  const intervalMs = Math.max(0, intervalDays) * 24 * 60 * 60 * 1000
+  return now - then < intervalMs && now >= then
+}
+
 // 📖 detectTerminalCapabilities: PURE terminal capability probe for TUI overlays.
 // 📖 WHY: basic server consoles (IPMI/KVM viewers, ASPEED framebuffer, serial
 // 📖 terminals) often run 80x24 or smaller with no or limited color support, and

package/src/tui/app.js

@@ -123,6 +123,7 @@ import { createOverlayRenderers } from './overlays.js'
 import { createKeyHandler, createMouseEventHandler } from './key-handler.js'
 import { createMouseHandler, containsMouseSequence } from './mouse.js'
 import { stopRouterDashboardClient } from '../core/router-dashboard.js'
+import { stopRouterV2DashboardClient } from '../core/router-v2/tui-dashboard.js'
 import { getToolModeOrder, getToolMeta } from '../core/tool-metadata.js'
 import { startExternalTool } from '../core/tool-launchers.js'
 import { getToolInstallPlan, installToolWithPlan, isToolInstalled } from '../core/tool-bootstrap.js'
@@ -758,6 +759,7 @@ export async function runApp(cliArgs, config, startupOptions = {}) {
     clearTimeout(state.pingIntervalObj)
     clearInterval(state.versionRecheckTimer)
     stopRouterDashboardClient(state)
+    stopRouterV2DashboardClient(state)
     process.stdout.write(ALT_LEAVE)
     if (process.stdout.isTTY) {
       process.stdout.flush && process.stdout.flush()
@@ -782,6 +784,7 @@ export async function runApp(cliArgs, config, startupOptions = {}) {
     clearTimeout(state.pingIntervalObj)
     clearInterval(state.versionRecheckTimer)
     stopRouterDashboardClient(state)
+    stopRouterV2DashboardClient(state)
     // 📖 Remove the actual registered wrappers (see keypressWrapper/mouseDataWrapper).
     if (keypressWrapper) process.stdin.removeListener('keypress', keypressWrapper)
     if (mouseDataWrapper) process.stdin.removeListener('data', mouseDataWrapper)
@@ -1118,6 +1121,8 @@ export async function runApp(cliArgs, config, startupOptions = {}) {
         ? overlays.renderInstalledModels()
       : state.routerDashboardOpen
         ? overlays.renderRouterDashboard()
+      : state.routerV2DashboardOpen
+        ? overlays.renderRouterV2Dashboard()
       : state.playgroundOpen
         ? overlays.renderPlayground()
       : state.tokenUsageOpen
@@ -1261,9 +1266,9 @@ export async function runApp(cliArgs, config, startupOptions = {}) {
     }
 
     state.results.forEach(r => {
-      // 📖 When router dashboard is open, ONLY ping favorites every second
+      // 📖 When a router dashboard is open, ONLY ping favorites every second
       // 📖 to prevent massive rate limiting across the entire 90+ model catalog.
-      if (state.routerDashboardOpen) {
+      if (state.routerDashboardOpen || state.routerV2DashboardOpen) {
         const favKey = `${r.providerKey}/${r.modelId}`
         if (!state.config.favorites.includes(favKey)) return
       }

package/src/tui/cli-help.js

@@ -47,6 +47,10 @@ const CONFIG_FLAGS = [
   { flag: '--daemon-bg', description: 'Start the FCM Router daemon in the background' },
   { flag: '--daemon-status', description: 'Print FCM Router daemon status JSON' },
   { flag: '--daemon-stop', description: 'Gracefully stop the FCM Router daemon' },
+  { flag: '--router-v2', description: 'Start the Router v2 daemon (BETA) on port 19380: content-validated failover + Anthropic /v1/messages' },
+  { flag: '--router-v2-bg', description: 'Start Router v2 (BETA) in the background' },
+  { flag: '--router-v2-status', description: 'Print Router v2 (BETA) daemon status JSON' },
+  { flag: '--router-v2-stop', description: 'Gracefully stop the Router v2 (BETA) daemon' },
   { flag: '--sync-set [name]', description: 'Auto-discover and live-probe models into a router set' },
   { flag: '--config-dir <dir>', description: 'Store config.json + backups/ in <dir> (e.g. --config-dir ~/.config/free-coding-models for the XDG layout)' },
   { flag: '--fix-permissions, --yes, -y', description: 'Auto-fix insecure config file permissions (chmod 600) without prompting; safe for scripts and CI' },

package/src/tui/key-handler.js

@@ -46,6 +46,15 @@ import {
   setDashboardNotice,
   toggleRouterDashboardProbePause,
 } from '../core/router-dashboard.js'
+import {
+  closeRouterV2DashboardOverlay,
+  cycleRouterV2ProbeMode,
+  openRouterV2DashboardOverlay,
+  renderRouterV2Dashboard,
+  setRouterV2Notice,
+  testAllVisibleViaRouterV2,
+  testModelViaRouterV2,
+} from '../core/router-v2/tui-dashboard.js'
 import {
   closePlaygroundOverlay,
   openPlaygroundOverlay,
@@ -82,8 +91,8 @@ function spawnDaemonCommand(state, args) {
   })
   child.unref()
 
-  // 📖 Only capture stdout for start commands — stop doesn't need error surfacing.
-  if (!args.includes('--daemon-bg')) return
+  // 📖 Only capture stdout for start commands - stop doesn't need error surfacing.
+  if (!args.includes('--daemon-bg') && !args.includes('--router-v2-bg')) return
 
   let stdout = ''
   let stderr = ''
@@ -1502,6 +1511,7 @@ export function createKeyHandler(ctx) {
 
       case 'open-recommend': return openRecommendOverlay()
       case 'open-router-dashboard': return openRouterDashboardOverlay(state)
+      case 'open-router-v2-dashboard': return openRouterV2DashboardOverlay(state)
       case 'open-playground': return openPlaygroundOverlay(state)
       case 'open-token-usage': return openTokenUsageOverlay()
       case 'open-runtime-report': return openRuntimeReportOverlay()
@@ -1774,6 +1784,82 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // 📖 Router v2 (BETA) dashboard: ↑↓ navigate the fallback chain,
+    // T tests the model under the cursor through the router (pinned request
+    // through the FULL chain), S toggles the daemon, I cycles probe speed,
+    // C clears the persisted history, Esc goes back.
+    if (state.routerV2DashboardOpen) {
+      const routingOrder = Array.isArray(state.routerV2Stats?.routingOrder) ? state.routerV2Stats.routingOrder : []
+      const maxCursor = Math.max(0, routingOrder.length)
+      const pageStep = Math.max(1, (state.terminalRows || 1) - 4)
+
+      if (key.name === 'escape') {
+        closeRouterV2DashboardOverlay(state)
+        return
+      }
+
+      if (key.name === 's') {
+        const isRunning = state.routerV2Status === 'ready' || state.routerV2Status === 'partial'
+        state.routerV2Status = 'loading'
+        spawnDaemonCommand(state, [isRunning ? '--daemon-stop' : '--daemon-bg'])
+        return
+      }
+
+      if (key.name === 'return' || key.name === 'enter') {
+        if ((state.routerV2CursorIndex ?? 0) === maxCursor) {
+          const isRunning = state.routerV2Status === 'ready' || state.routerV2Status === 'partial'
+          state.routerV2Status = 'loading'
+          spawnDaemonCommand(state, [isRunning ? '--daemon-stop' : '--daemon-bg'])
+        }
+        return
+      }
+
+      if (key.name === 't') {
+        const entry = routingOrder[state.routerV2CursorIndex ?? 0]
+        if (entry?.key) void testModelViaRouterV2(state, entry.key)
+        return
+      }
+
+      if (key.name === 'up' || key.name === 'k') {
+        state.routerV2CursorIndex = Math.max(0, (state.routerV2CursorIndex ?? 0) - 1)
+        return
+      }
+      if (key.name === 'down' || key.name === 'j') {
+        state.routerV2CursorIndex = Math.min(maxCursor, (state.routerV2CursorIndex ?? 0) + 1)
+        return
+      }
+      if (key.name === 'pageup') {
+        state.routerV2ScrollOffset = Math.max(0, (state.routerV2ScrollOffset || 0) - pageStep)
+        return
+      }
+      if (key.name === 'pagedown') {
+        state.routerV2ScrollOffset = (state.routerV2ScrollOffset || 0) + pageStep
+        return
+      }
+      if (key.name === 'home') {
+        state.routerV2CursorIndex = 0
+        state.routerV2ScrollOffset = 0
+        return
+      }
+      if (key.name === 'i') {
+        try { await cycleRouterV2ProbeMode(state) } catch {}
+        return
+      }
+      if (key.name === 'c') {
+        void (async () => {
+          try {
+            if (state.routerV2BaseUrl) {
+              await fetch(`${state.routerV2BaseUrl}/api/router-v2/history`, { method: 'DELETE' })
+              state.routerV2History = null
+              setRouterV2Notice(state, 'success', 'Request history cleared.')
+            }
+          } catch {}
+        })()
+        return
+      }
+      return
+    }
+
     // 📖 Playground overlay: handles Enter, Esc, Backspace, Ctrl+S, Ctrl+L,
     // 📖 PageUp/PageDown, and printable input itself. The dedicated handler
     // 📖 in core/playground.js owns the draft and submission state.
@@ -2926,6 +3012,16 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // 📖 Shift+V: Open / close the Router v2 (BETA) dashboard.
+    if (key.name === 'v' && key.shift && !key.ctrl && !key.meta) {
+      if (state.routerV2DashboardOpen) {
+        closeRouterV2DashboardOverlay(state)
+        return
+      }
+      openRouterV2DashboardOverlay(state)
+      return
+    }
+
     // 📖 Shift+T: open the Token Usage screen.
     if (key.name === 't' && key.shift && !key.ctrl && !key.meta) {
       openTokenUsageOverlay()
@@ -3070,6 +3166,25 @@ export function createKeyHandler(ctx) {
       return
     }
 
+    // 📖 Ctrl+T: test the selected model THROUGH the Router v2 daemon (beta).
+    // 📖 Unlike Ctrl+A (direct provider call), this exercises the full routing
+    // chain: schema normalization, pre-prompt, content gate and the breaker
+    // update. The pinned-model request runs with failover disabled.
+    if (key.ctrl && key.name === 't' && !key.shift) {
+      const selected = state.visibleSorted?.[state.cursor]
+      if (selected?.providerKey && selected?.modelId) {
+        void testModelViaRouterV2(state, `${selected.providerKey}/${selected.modelId}`)
+      }
+      return
+    }
+
+    // 📖 Ctrl+Shift+T: test every visible configured model through Router v2,
+    // results streaming into the Shift+V overlay as they land.
+    if (key.ctrl && key.shift && key.name === 't') {
+      void testAllVisibleViaRouterV2(state)
+      return
+    }
+
     if (key.shift && key.name === 'up') {
       const selected = state.visibleSorted?.[state.cursor]
       if (selected?.isFavorite) {