@geminilight/mindos 0.6.52 → 0.6.54

package/bin/commands/space.js

@@ -7,7 +7,7 @@
  */
 
 import { existsSync, readdirSync, statSync, mkdirSync, writeFileSync, rmSync, renameSync } from 'node:fs';
-import { resolve, basename } from 'node:path';
+import { resolve, basename, relative, sep } from 'node:path';
 import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
 import { loadConfig } from '../lib/config.js';
 import { output, isJsonMode, EXIT } from '../lib/command.js';
@@ -93,9 +93,12 @@ function countFiles(dir) {
 
 function resolvePath(root, relPath) {
   const full = relPath ? resolve(root, relPath) : root;
-  if (full !== root && !full.startsWith(root + '/')) {
-    console.error(red(`Access denied: path outside knowledge base`));
-    process.exit(EXIT.ERROR);
+  if (full !== root) {
+    const rel = relative(root, full);
+    if (rel === '..' || rel.startsWith(`..${sep}`) || rel.startsWith('../')) {
+      console.error(red(`Access denied: path outside knowledge base`));
+      process.exit(EXIT.ERROR);
+    }
   }
   if (!existsSync(full)) {
     console.error(red(`Not found: ${relPath || '(root)'}`));

package/bin/commands/update.js

@@ -5,7 +5,7 @@
  */
 
 import { execSync, spawn as nodeSpawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, realpathSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 
 import { ROOT, BUILD_STAMP, CONFIG_PATH, LOG_PATH } from '../lib/constants.js';
@@ -15,6 +15,8 @@ import { EXIT } from '../lib/command.js';
 import { stopMindos } from '../lib/stop.js';
 import { getLocalIP } from '../lib/startup.js';
 import { isPortInUse } from '../lib/port.js';
+import { cleanEnvForRestart } from '../lib/clean-env.js';
+import { stripBom } from '../lib/jsonc.js';
 
 /**
  * Dynamically resolve the new ROOT after `npm install -g`.
@@ -22,27 +24,16 @@ import { isPortInUse } from '../lib/port.js';
  */
 function getUpdatedRoot() {
   try {
-    const mindosBin = execSync('which mindos', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const whichCmd = process.platform === 'win32' ? 'where mindos' : 'which mindos';
+    const mindosBin = execSync(whichCmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim().split(/\r?\n/)[0];
     if (mindosBin) {
-      // mindos bin is usually at <root>/bin/cli.js or a symlink to it
       let cliPath;
-      try {
-        cliPath = execSync(`readlink -f "${mindosBin}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-      } catch {
-        try {
-          cliPath = execSync(`realpath "${mindosBin}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-        } catch {
-          cliPath = mindosBin;
-        }
-      }
+      try { cliPath = realpathSync(mindosBin); } catch { cliPath = mindosBin; }
       if (cliPath) {
-        // cliPath is like /path/to/node_modules/@geminilight/mindos/bin/cli.js
-        // ROOT is /path/to/node_modules/@geminilight/mindos
         return resolve(dirname(cliPath), '..');
       }
     }
   } catch {}
-  // Fallback to static ROOT
   return ROOT;
 }
 
@@ -84,7 +75,7 @@ function buildIfNeeded(newRoot) {
   }
   const nextDir = resolve(newRoot, 'app', '.next');
   if (existsSync(nextDir)) {
-    execInherited(`rm -rf "${nextDir}"`, newRoot);
+    rmSync(nextDir, { recursive: true, force: true });
   }
   execInherited('node scripts/gen-renderer-index.js', newRoot);
   execInherited(`${newNextBin} build`, resolve(newRoot, 'app'));
@@ -175,12 +166,12 @@ export const run = async () => {
     writeUpdateStatus('restarting', vOpts);
     await gateway.runGatewayCommand('install');
     const updateConfig = (() => {
-      try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { return {}; }
+      try { return JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8'))); } catch { return {}; }
     })();
     const webPort = updateConfig.port ?? 3456;
     const mcpPort = updateConfig.mcpPort ?? 8781;
     console.log(dim('  (Waiting for Web UI to come back up — first run after update includes a rebuild...)'));
-    const ready = await gateway.waitForHttp(Number(webPort), { retries: 450, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+    const ready = await gateway.waitForHttp(Number(webPort), { retries: 450, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH, expectedVersion: newVersion });
     if (ready) {
       const localIP = getLocalIP();
       console.log(`\n${'─'.repeat(53)}`);
@@ -204,7 +195,7 @@ export const run = async () => {
     // (e.g. user started via `mindos start`, or GUI triggered this update).
     // If so, stop it and restart from the NEW installation path.
     const updateConfig = (() => {
-      try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { return {}; }
+      try { return JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8'))); } catch { return {}; }
     })();
     const webPort = Number(updateConfig.port ?? 3456);
     const mcpPort = Number(updateConfig.mcpPort ?? 8781);
@@ -214,13 +205,29 @@ export const run = async () => {
     if (wasRunning) {
       console.log(cyan('\n  MindOS is running — restarting to apply the new version...'));
       stopMindos();
-      // Wait for ports to free (up to 15s)
-      const deadline = Date.now() + 15_000;
+      // Wait for ports to free (up to 20s) with stabilization check.
+      // After first "free" reading, wait 1s and check again to avoid
+      // false negatives from TCP TIME_WAIT flickering.
+      const deadline = Date.now() + 20_000;
+      let portsFree = false;
       while (Date.now() < deadline) {
         const busy = await isPortInUse(webPort) || await isPortInUse(mcpPort);
-        if (!busy) break;
+        if (!busy) {
+          // Stabilization: wait 1s, then double-check
+          await new Promise((r) => setTimeout(r, 1000));
+          const stillFree = !(await isPortInUse(webPort)) && !(await isPortInUse(mcpPort));
+          if (stillFree) { portsFree = true; break; }
+        }
         await new Promise((r) => setTimeout(r, 500));
       }
+      if (!portsFree) {
+        console.log(yellow('  ⚠ Ports not fully released, force-killing remaining processes...'));
+        // Last resort: import killByPort and SIGKILL anything on these ports
+        const stopLib = await import('../lib/stop.js');
+        stopLib.killByPort(webPort);
+        stopLib.killByPort(mcpPort);
+        await new Promise((r) => setTimeout(r, 2000));
+      }
 
       // Stage 3: Rebuild
       writeUpdateStatus('rebuilding', vOpts);
@@ -237,12 +244,7 @@ export const run = async () => {
       // (`mindos start` has its own build-on-startup logic)
       writeUpdateStatus('restarting', vOpts);
       const newCliPath = resolve(updatedRoot, 'bin', 'cli.js');
-      const childEnv = { ...process.env };
-      delete childEnv.MINDOS_WEB_PORT;
-      delete childEnv.MINDOS_MCP_PORT;
-      delete childEnv.MIND_ROOT;
-      delete childEnv.AUTH_TOKEN;
-      delete childEnv.WEB_PASSWORD;
+      const childEnv = cleanEnvForRestart();
       const child = nodeSpawn(
         process.execPath, [newCliPath, 'start'],
         { detached: true, stdio: 'ignore', env: childEnv },
@@ -250,7 +252,7 @@ export const run = async () => {
       child.unref();
 
       console.log(dim('  (Waiting for Web UI to come back up...)'));
-      const ready = await gateway.waitForHttp(webPort, { retries: 180, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+      const ready = await gateway.waitForHttp(webPort, { retries: 180, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH, expectedVersion: newVersion });
       if (ready) {
         const localIP = getLocalIP();
         console.log(`\n${'─'.repeat(53)}`);

package/bin/lib/build.js

@@ -118,13 +118,19 @@ export function ensureAppDeps({ force = false } = {}) {
   } catch {
     console.error(red('\n\u2718 npm not found in PATH.\n'));
     console.error('  MindOS needs npm to install its app dependencies on first run.');
-    console.error('  This usually means Node.js is installed via a version manager (nvm, fnm, volta, etc.)');
-    console.error('  that only loads in interactive shells, but not in /bin/sh.\n');
-    console.error('  Fix: add your Node.js bin directory to a profile that /bin/sh reads (~/.profile).');
-    console.error('  Example:');
-    console.error(dim('    echo \'export PATH="$HOME/.nvm/versions/node/$(node --version)/bin:$PATH"\' >> ~/.profile'));
-    console.error(dim('    source ~/.profile\n'));
-    console.error('  Then run `mindos start` again.\n');
+    if (process.platform === 'win32') {
+      console.error('  Ensure Node.js is installed and added to your system PATH.\n');
+      console.error('  Fix: reinstall Node.js from https://nodejs.org (the installer adds it to PATH).');
+      console.error('  Then open a new terminal and run `mindos start` again.\n');
+    } else {
+      console.error('  This usually means Node.js is installed via a version manager (nvm, fnm, volta, etc.)');
+      console.error('  that only loads in interactive shells, but not in /bin/sh.\n');
+      console.error('  Fix: add your Node.js bin directory to a profile that /bin/sh reads (~/.profile).');
+      console.error('  Example:');
+      console.error(dim('    echo \'export PATH="$HOME/.nvm/versions/node/$(node --version)/bin:$PATH"\' >> ~/.profile'));
+      console.error(dim('    source ~/.profile\n'));
+      console.error('  Then run `mindos start` again.\n');
+    }
     process.exit(1);
   }
 
@@ -142,7 +148,12 @@ export function ensureAppDeps({ force = false } = {}) {
     run('npm install --no-workspaces', resolve(ROOT, 'app'));
     if (!verifyDeps()) {
       console.error(red('\n✘ Failed to install dependencies after retry.\n'));
-      console.error('  Try manually: cd ' + resolve(ROOT, 'app') + ' && rm -rf node_modules && npm install');
+      const appDir = resolve(ROOT, 'app');
+      if (process.platform === 'win32') {
+        console.error(`  Try manually: cd "${appDir}" && rmdir /s /q node_modules && npm install`);
+      } else {
+        console.error(`  Try manually: cd ${appDir} && rm -rf node_modules && npm install`);
+      }
       process.exit(1);
     }
   }

package/bin/lib/clean-env.js

@@ -0,0 +1,38 @@
+/**
+ * Create a clean environment for spawning a new MindOS process.
+ *
+ * During `mindos update`, the old process inherits env vars like
+ * MINDOS_PROJECT_ROOT, MINDOS_CLI_PATH etc. that point to the OLD
+ * installation path. If these leak into the child process, the "new"
+ * server starts from the old code — the infamous "fake update" bug.
+ *
+ * This helper strips ALL MINDOS_*/MIND_* prefixed variables plus
+ * a curated denylist of other vars that can cause stale-path issues.
+ */
+
+/** Env var prefixes that must be stripped for a clean restart */
+const STRIP_PREFIXES = ['MINDOS_', 'MIND_'];
+
+/** Additional specific vars to strip (not prefix-matched) */
+const STRIP_EXACT = [
+  'AUTH_TOKEN',
+  'WEB_PASSWORD',
+  'NODE_OPTIONS', // may contain --inspect or old module paths
+];
+
+/**
+ * Return a copy of `process.env` with all MindOS-related vars removed.
+ * The new child process will re-derive paths from its own ROOT constant.
+ */
+export function cleanEnvForRestart(baseEnv = process.env) {
+  const cleaned = { ...baseEnv };
+  for (const key of Object.keys(cleaned)) {
+    if (STRIP_PREFIXES.some(p => key.startsWith(p))) {
+      delete cleaned[key];
+    }
+  }
+  for (const key of STRIP_EXACT) {
+    delete cleaned[key];
+  }
+  return cleaned;
+}

package/bin/lib/cli-shim.js

@@ -66,6 +66,65 @@ exit 127
   try { chmodSync(shimPath(), 0o755); } catch { /* ignore */ }
 }
 
+function writeWindowsShim(cliJs) {
+  const script = `@echo off\r
+rem Generated by MindOS CLI — overwritten on each mindos start.\r
+setlocal\r
+set "CLI=${cliJs}"\r
+if not exist "%CLI%" (\r
+  for /f "delims=" %%R in ('npm root -g 2^>nul') do set "NPM_CLI=%%R\\@geminilight\\mindos\\bin\\cli.js"\r
+  if defined NPM_CLI if exist "%NPM_CLI%" set "CLI=%NPM_CLI%"\r
+)\r
+if not exist "%CLI%" (\r
+  echo mindos: CLI not found. Reinstall: npm install -g @geminilight/mindos >&2\r
+  exit /b 127\r
+)\r
+set "MINDOS_NODE=%USERPROFILE%\\.mindos\\node\\node.exe"\r
+if exist "%MINDOS_NODE%" (\r
+  "%MINDOS_NODE%" "%CLI%" %*\r
+  exit /b %ERRORLEVEL%\r
+)\r
+where node >nul 2>nul\r
+if %ERRORLEVEL% equ 0 (\r
+  node "%CLI%" %*\r
+  exit /b %ERRORLEVEL%\r
+)\r
+echo mindos: Node.js not found. Install Node 18+ or run MindOS Desktop. >&2\r
+exit /b 127\r
+`;
+  mkdirSync(shimDir(), { recursive: true });
+  writeFileSync(shimPath(), script, 'utf-8');
+}
+
+/**
+ * On Windows, add ~/.mindos/bin to user PATH via PowerShell profile (idempotent).
+ * Falls back gracefully if PowerShell is not available.
+ */
+function appendPathWindows() {
+  const binDir = shimDir();
+  const dirs = (process.env.PATH || '').split(';');
+  if (dirs.some(d => d === binDir)) return false;
+
+  // Write a PowerShell profile snippet
+  try {
+    const psProfileDir = resolve(home, 'Documents', 'WindowsPowerShell');
+    mkdirSync(psProfileDir, { recursive: true });
+    const psProfile = resolve(psProfileDir, 'Microsoft.PowerShell_profile.ps1');
+    const psBlock = `\n${SHELL_MARKER}\n$env:PATH = "$env:USERPROFILE\\.mindos\\bin;$env:PATH"\n`;
+
+    let needsWrite = !existsSync(psProfile);
+    if (!needsWrite) {
+      const content = readFileSync(psProfile, 'utf-8');
+      needsWrite = !content.includes(SHELL_MARKER) && !content.includes('.mindos\\bin');
+    }
+    if (needsWrite) {
+      appendFileSync(psProfile, psBlock, 'utf-8');
+      return true;
+    }
+  } catch { /* best effort */ }
+  return false;
+}
+
 /**
  * Append ~/.mindos/bin to PATH in relevant shell rc files (idempotent).
  * AI Agents run commands via non-interactive shells:
@@ -74,7 +133,9 @@ exit 127
  * - Fish reads ~/.config/fish/conf.d/*.fish always
  */
 function appendPathToShellRc() {
-  if (platform() === 'win32') return false;
+  if (platform() === 'win32') {
+    return appendPathWindows();
+  }
 
   const block = `\n${SHELL_MARKER}\nexport PATH="$HOME/.mindos/bin:$PATH"\n`;
 
@@ -144,7 +205,11 @@ function appendPathToShellRc() {
  */
 export function ensureCliShim() {
   try {
-    writeUnixShim(CLI_PATH);
+    if (platform() === 'win32') {
+      writeWindowsShim(CLI_PATH);
+    } else {
+      writeUnixShim(CLI_PATH);
+    }
   } catch (e) {
     console.warn('[MindOS] Failed to write CLI shim:', e instanceof Error ? e.message : e);
     return false;

package/bin/lib/config.js

@@ -1,5 +1,6 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { CONFIG_PATH } from './constants.js';
+import { stripBom } from './jsonc.js';
 
 let loaded = false;
 
@@ -9,7 +10,7 @@ export function loadConfig() {
   if (!existsSync(CONFIG_PATH)) return;
   let config;
   try {
-    config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    config = JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8')));
   } catch {
     console.error(`Warning: failed to parse ${CONFIG_PATH}`);
     return;
@@ -49,9 +50,7 @@ export function loadConfig() {
 
 export function getStartMode() {
   try {
-    const mode = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).startMode || 'start';
-    // 'daemon' is stored in config when user chose background service;
-    // CLI maps it to the 'start' command with --daemon flag
+    const mode = JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8'))).startMode || 'start';
     return mode === 'daemon' ? 'start' : mode;
   } catch {
     return 'start';
@@ -60,7 +59,7 @@ export function getStartMode() {
 
 export function isDaemonMode() {
   try {
-    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).startMode === 'daemon';
+    return JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8'))).startMode === 'daemon';
   } catch {
     return false;
   }

package/bin/lib/gateway.js

@@ -1,10 +1,11 @@
 import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync, renameSync, unlinkSync, openSync, readSync, closeSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, statSync, renameSync, unlinkSync, openSync, readSync, closeSync, realpathSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { homedir } from 'node:os';
 import { MINDOS_DIR, LOG_PATH, CLI_PATH, NODE_BIN, CONFIG_PATH } from './constants.js';
 import { green, red, dim, cyan, yellow } from './colors.js';
 import { isPortInUse } from './port.js';
+import { stripBom } from './jsonc.js';
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -15,31 +16,17 @@ import { isPortInUse } from './port.js';
  */
 function getCurrentCliPath() {
   try {
-    // Try to find mindos in PATH
-    const mindosBin = execSync('which mindos', { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+    const whichCmd = process.platform === 'win32' ? 'where mindos' : 'which mindos';
+    // `where` on Windows can return multiple lines; take the first match
+    const mindosBin = execSync(whichCmd, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim().split(/\r?\n/)[0];
     if (mindosBin) {
-      // mindos is usually a symlink, resolve it
       try {
-        const realPath = execSync(`readlink -f "${mindosBin}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-        if (realPath && existsSync(realPath)) {
-          return realPath;
-        }
-      } catch {
-        // readlink -f not available on macOS, fallback to realpath
-        try {
-          const realPath = execSync(`realpath "${mindosBin}"`, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-          if (realPath && existsSync(realPath)) {
-            return realPath;
-          }
-        } catch {}
-      }
-      // Fallback: use the symlink target itself
-      if (existsSync(mindosBin)) {
-        return mindosBin;
-      }
+        const realPath = realpathSync(mindosBin);
+        if (existsSync(realPath)) return realPath;
+      } catch {}
+      if (existsSync(mindosBin)) return mindosBin;
     }
   } catch {}
-  // Fallback to static CLI_PATH if dynamic resolution fails
   return CLI_PATH;
 }
 
@@ -113,13 +100,43 @@ export function parseLogHint(line) {
   return null;
 }
 
-export async function waitForHttp(port, { retries = 60, intervalMs = 2000, label = 'service', logFile = null } = {}) {
+export async function waitForHttp(port, { retries = 60, intervalMs = 2000, label = 'service', logFile = null, expectedVersion = null } = {}) {
   const start = Date.now();
   const elapsed = () => {
     const s = Math.round((Date.now() - start) / 1000);
     return s < 60 ? `${s}s` : `${Math.floor(s / 60)}m${String(s % 60).padStart(2, '0')}s`;
   };
 
+  /**
+   * Version-aware readiness check: after health check passes, verify the
+   * server is actually running the expected version (not an orphaned old process).
+   * Prevents the "fake update" where health check hits a stale worker.
+   */
+  async function verifyVersion(hostname) {
+    if (!expectedVersion) return true; // no version check requested
+    try {
+      const { request } = await import('node:http');
+      return new Promise((resolve) => {
+        const req = request(
+          { hostname, port, path: '/api/update-check', method: 'GET', timeout: 5000 },
+          (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => {
+              try {
+                const data = JSON.parse(body);
+                resolve(data.current === expectedVersion);
+              } catch { resolve(false); }
+            });
+          }
+        );
+        req.on('error', () => resolve(false));
+        req.on('timeout', () => { req.destroy(); resolve(false); });
+        req.end();
+      });
+    } catch { return false; }
+  }
+
   // Track log file position for incremental reads
   let logOffset = 0;
   let lastHint = 'starting…';
@@ -169,9 +186,16 @@ export async function waitForHttp(port, { retries = 60, intervalMs = 2000, label
       });
       const ok = await tryHost('127.0.0.1') || await tryHost('localhost');
       if (ok) {
-        process.stdout.write(`\r\x1b[K`);
-        process.stdout.write(`  ${green('\u2714')} ${label} ready ${dim(`(${elapsed()})`)}\n`);
-        return true;
+        // If expectedVersion is set, verify the server is running the right version
+        const versionOk = await verifyVersion('127.0.0.1') || await verifyVersion('localhost');
+        if (!versionOk && expectedVersion) {
+          // Health check passed but wrong version — old process still serving
+          // Continue waiting for the new process to take over
+        } else {
+          process.stdout.write(`\r\x1b[K`);
+          process.stdout.write(`  ${green('\u2714')} ${label} ready ${dim(`(${elapsed()})`)}\n`);
+          return true;
+        }
       }
     } catch { /* not ready yet */ }
 
@@ -353,7 +377,7 @@ const launchd = {
     // Read ports before bootout so we can wait for them to be freed
     let webPort = 3456, mcpPort = 8781;
     try {
-      const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      const config = JSON.parse(stripBom(readFileSync(CONFIG_PATH, 'utf-8')));
       if (config.port) webPort = Number(config.port);
       if (config.mcpPort) mcpPort = Number(config.mcpPort);
     } catch {}

package/bin/lib/jsonc.js

@@ -1,11 +1,16 @@
 /**
- * JSONC parser — strips comments before JSON.parse.
+ * JSONC parser — strips BOM and comments before JSON.parse.
  *
  * VS Code-based editors (Cursor, Windsurf, Cline) use JSONC for config files.
+ * Windows editors (Notepad) may prepend a UTF-8 BOM (\uFEFF).
  */
 
+export function stripBom(text) {
+  return text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text;
+}
+
 export const parseJsonc = (text) => {
-  let stripped = text.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)/gm, (m, g) => g ? '' : m);
+  let stripped = stripBom(text).replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)/gm, (m, g) => g ? '' : m);
   stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
   if (!stripped.trim()) return {};
   return JSON.parse(stripped);

package/bin/lib/mcp-agents.js

@@ -9,8 +9,14 @@
 
 import { existsSync } from 'node:fs';
 import { execSync } from 'node:child_process';
+import { resolve } from 'node:path';
 import { expandHome } from './path-expand.js';
 
+function winAppData(...segments) {
+  const appData = process.env.APPDATA || resolve(process.env.USERPROFILE || '', 'AppData', 'Roaming');
+  return resolve(appData, ...segments);
+}
+
 export const MCP_AGENTS = {
   'claude-code': {
     name: 'Claude Code',
@@ -42,12 +48,15 @@ export const MCP_AGENTS = {
     project: null,
     global: process.platform === 'darwin'
       ? '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json'
-      : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json',
+      : process.platform === 'win32'
+        ? winAppData('Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json')
+        : '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
     presenceDirs: [
       '~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/',
       '~/.config/Code/User/globalStorage/saoudrizwan.claude-dev/',
+      ...(process.platform === 'win32' ? [winAppData('Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev')] : []),
     ],
   },
   'trae': {
@@ -153,13 +162,16 @@ export const MCP_AGENTS = {
     project: '.trae/mcp.json',
     global: process.platform === 'darwin'
       ? '~/Library/Application Support/Trae CN/User/mcp.json'
-      : '~/.config/Trae CN/User/mcp.json',
+      : process.platform === 'win32'
+        ? winAppData('Trae CN', 'User', 'mcp.json')
+        : '~/.config/Trae CN/User/mcp.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
     presenceCli: 'trae-cli',
     presenceDirs: [
       '~/Library/Application Support/Trae CN/',
       '~/.config/Trae CN/',
+      ...(process.platform === 'win32' ? [winAppData('Trae CN')] : []),
     ],
   },
   'roo': {
@@ -167,12 +179,15 @@ export const MCP_AGENTS = {
     project: '.roo/mcp.json',
     global: process.platform === 'darwin'
       ? '~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json'
-      : '~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json',
+      : process.platform === 'win32'
+        ? winAppData('Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline', 'settings', 'mcp_settings.json')
+        : '~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/mcp_settings.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
     presenceDirs: [
       '~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/',
       '~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/',
+      ...(process.platform === 'win32' ? [winAppData('Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline')] : []),
     ],
   },
   'github-copilot': {
@@ -180,12 +195,15 @@ export const MCP_AGENTS = {
     project: '.vscode/mcp.json',
     global: process.platform === 'darwin'
       ? '~/Library/Application Support/Code/User/mcp.json'
-      : '~/.config/Code/User/mcp.json',
+      : process.platform === 'win32'
+        ? winAppData('Code', 'User', 'mcp.json')
+        : '~/.config/Code/User/mcp.json',
     key: 'servers',
     preferredTransport: 'stdio',
     presenceDirs: [
       '~/Library/Application Support/Code/',
       '~/.config/Code/',
+      ...(process.platform === 'win32' ? [winAppData('Code')] : []),
     ],
     presenceCli: 'code',
   },
@@ -239,6 +257,9 @@ export function detectAgentPresence(agentKey) {
       return true;
     } catch { /* not found */ }
   }
-  if (agent.presenceDirs?.some(d => existsSync(expandHome(d)))) return true;
+  if (agent.presenceDirs?.some(d => {
+    // Paths from winAppData() are already absolute; expandHome only handles ~/
+    try { return existsSync(d.startsWith('~') ? expandHome(d) : d); } catch { return false; }
+  })) return true;
   return false;
 }

package/bin/lib/path-expand.js

@@ -1,9 +1,12 @@
 /**
- * Path expansion — resolve `~/...` to absolute paths.
+ * Path expansion — resolve `~/...` or `~\...` to absolute paths.
  */
 
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 
-export const expandHome = (p) =>
-  p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
+export const expandHome = (p) => {
+  if (p === '~') return homedir();
+  if (p.startsWith('~/') || p.startsWith('~\\')) return resolve(homedir(), p.slice(2));
+  return p;
+};

package/bin/lib/port.js

@@ -33,7 +33,11 @@ export async function assertPortFree(port, name) {
   if (await isPortInUse(port)) {
     console.error(`\n${red('\u2718')} ${bold(`Port ${port} is still in use after cleanup`)} ${dim(`(${name})`)}`);
     console.error(`\n  ${dim('Stop MindOS:')}       mindos stop`);
-    console.error(`  ${dim('Find the process:')}  lsof -i :${port}\n`);
+    if (process.platform === 'win32') {
+      console.error(`  ${dim('Find the process:')}  netstat -ano | findstr :${port}\n`);
+    } else {
+      console.error(`  ${dim('Find the process:')}  lsof -i :${port}\n`);
+    }
     process.exit(1);
   }
   console.log(`  ${dim('Cleaned up orphaned processes on port')} ${port}`);