free-coding-models 0.5.87 → 0.5.88

package/README.md

@@ -27,10 +27,6 @@ free-coding-models
   <sub>Then create a free account on one of the <a href="#-providers">24 providers</a> to grab an API key.</sub>
 </p>
 
-<p align="center">
-  <img src="website/public/demo.gif" alt="free-coding-models demo" width="100%">
-</p>
-
 <p align="center">
   <sub>Made with ❤️ and ☕ by <a href="https://vanessadepraute.dev">Vanessa Depraute</a> (aka <a href="https://vavanessa.dev">Vava-Nessa</a>)</sub>
 </p>
@@ -87,10 +83,6 @@ free-coding-models --fiable              # print the single most reliable model
 - 🔀 Want one endpoint that never dies? `free-coding-models --daemon-bg` starts the [Smart Model Router](./docs/router.md).
 - 🤖 Live inside an agent? Install the [OpenCode plugin](./packages/fcm-opencode/README.md) or the [Pi extension](./packages/fcm-pi/README.md).
 
-<p align="center">
-  <img src="demo2.gif" alt="free-coding-models TUI demo" width="100%">
-</p>
-
 ---
 
 ## 🟢 Providers
@@ -179,7 +171,7 @@ Flags combine freely in any order. The most common:
 | `--reprobe` / `--probe-ttl <ms>` / `--show-broken` | Probe cache control |
 | `--check-drift` | Diff `sources.js` vs models.dev, exit 1 on mismatch |
 | `--config-dir <dir>` | Custom config location |
-| `--fix-permissions` / `--yes` | Auto-fix config file permissions (chmod 600) |
+| `--fix-permissions` / `--yes` | Auto-fix config file permissions (chmod 600, NTFS ACLs via icacls on Windows) |
 | `--web` | Open the Web Dashboard instead of the TUI |
 | `--daemon` / `--daemon-bg` / `--daemon-status` / `--daemon-stop` | Smart Model Router lifecycle |
 | `--sync-set [name]` | Auto-populate a router set with the currently best models |

package/changelog/v0.5.88.md

@@ -0,0 +1,16 @@
+# Changelog v0.5.88 - 2026-09-06
+
+### Fixed
+- **Windows: the config permissions warning no longer re-fires on every launch** (issue #173 follow-up reported by @rutexd). On Windows, Node can only report file modes 0666 (writable) or 0444 (read-only), so the old "is it 600?" check could never pass: the app warned, you answered yes, it said "fixed!", and the next launch warned again in an endless loop.
+  - The Windows security verdict now comes from the real NTFS ACL, read with `icacls <file>` and parsed by a new pure helper (`parseIcaclsOutput`). The file counts as protected when NTFS inheritance is disabled and only your user (plus trusted SYSTEM/Administrators entries, matched by name or well-known SID, locale-proof) has access.
+  - Fixing on Windows now runs `icacls "<file>" /inheritance:r /grant:r "<user>:F"` (no shell, injection-safe) instead of the no-op chmod, and the fix is **verified by re-reading the ACL** before the app claims success. No more fake "✅ Permissions fixed!".
+  - The warning now explains *what* is wrong on NTFS (inherited access, or which other principals have a grant) instead of showing a meaningless octal mode.
+- **Anti-nag guard (all platforms)**: when the fix genuinely cannot be applied or verified (rare), the app now writes a small ack marker next to the config file and stays quiet about the same warning for 30 days, instead of nagging on every single launch. Passing `--fix-permissions` / `--yes` / `-y` always bypasses the marker and retries. The marker is cleaned up as soon as a fix succeeds.
+- The manual fix hint on Windows now shows the exact `icacls` command with your real username, and the POSIX path (chmod 600) additionally re-checks the mode after chmod so success messages are always truthful.
+
+### Changed
+- `--fix-permissions` documentation now mentions it applies NTFS ACLs on Windows (README flags table).
+
+### For contributors
+- New pure helpers in `src/core/utils.js`, fully unit-tested: `parseIcaclsOutput` (icacls output parser, handles the echoed path glued to the first ACE, `(I)` inheritance markers, SIDs and localized group names) and `shouldSkipSecurityWarn` (30-day anti-nag gate, ISO string or epoch input, clock-skew safe).
+- `checkConfigSecurity()` gained an integration test covering the full lifecycle: warn once, ack, stay silent on relaunch, auto-fix bypasses the ack, marker cleanup after a successful fix.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.5.87",
+  "version": "0.5.88",
   "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",
@@ -94,5 +94,10 @@
     "react": "^19.2.7",
     "react-dom": "^19.2.7",
     "vite": "^8.0.16"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
   }
 }

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

@@ -750,6 +750,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