@geminilight/mindos 0.6.40 → 0.6.41

package/bin/commands/start.js

@@ -0,0 +1,262 @@
+/**
+ * mindos start — production app + MCP server
+ */
+
+import { execSync, execFileSync } from 'node:child_process';
+import {
+  existsSync,
+  readFileSync,
+  mkdirSync,
+  cpSync,
+  unlinkSync,
+} from 'node:fs';
+import { resolve } from 'node:path';
+
+import { ROOT, CONFIG_PATH, LOG_PATH } from '../lib/constants.js';
+import { dim, cyan, green, red, yellow } from '../lib/colors.js';
+import { loadConfig, isDaemonMode } from '../lib/config.js';
+import {
+  ensureAppDeps,
+  needsBuild,
+  cleanNextDir,
+  writeBuildStamp,
+  hasPrebuiltStandalone,
+} from '../lib/build.js';
+import { assertPortFree } from '../lib/port.js';
+import { savePids, clearPids } from '../lib/pid.js';
+import { killByPort } from '../lib/stop.js';
+import { printStartupInfo } from '../lib/startup.js';
+import { spawnMcp } from '../lib/mcp-spawn.js';
+import { EXIT } from '../lib/command.js';
+import { execInherited } from '../lib/shell.js';
+
+/** Local Next.js binary (avoids a mismatched global `next`). */
+const NEXT_BIN = resolve(ROOT, 'app', 'node_modules', '.bin', 'next');
+
+/** Command metadata for registry / help. */
+export const meta = {
+  name: 'start',
+  group: 'Service',
+  summary: 'Start MindOS services',
+  usage: 'mindos start',
+  flags: {
+    '--daemon': 'Run as background daemon',
+    '--verbose': 'Show detailed output',
+    '--port <port>': 'Override web port',
+  },
+  examples: [
+    'mindos start',
+    'mindos start --daemon',
+    'mindos start --verbose',
+  ],
+};
+
+/**
+ * Start MindOS in production (foreground or OS service when `--daemon` / config daemon mode).
+ *
+ * @param {string[]} args — forwarded to `next start` after `-p <port>`
+ * @param {Record<string, unknown>} flags — e.g. `daemon`, `verbose`
+ * @returns {Promise<void>}
+ */
+export const run = async (args, flags) => {
+  const isDaemon = Boolean(flags.daemon) || isDaemonMode();
+  const isVerbose = Boolean(flags.verbose);
+  const extra = args.join(' ');
+
+  // Check for incomplete setup
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const cfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      if (cfg.setupPending === true) {
+        console.log(
+          `\n  ${yellow('⚠ Setup was not completed.')} Run ${cyan('mindos onboard')} to finish, or ${cyan('mindos config set setupPending false')} to dismiss.\n`,
+        );
+      }
+    } catch { /* ignore malformed config */ }
+  }
+
+  if (isDaemon) {
+    const { getPlatform, runGatewayCommand, waitForHttp } = await import('../lib/gateway.js');
+    const platform = getPlatform();
+    if (!platform) {
+      console.warn(
+        yellow('Warning: daemon mode not supported on this platform. Falling back to foreground.'),
+      );
+    } else {
+      loadConfig();
+      if (!process.env.MINDOS_WEB_PORT) process.env.MINDOS_WEB_PORT = '3456';
+      if (!process.env.MINDOS_MCP_PORT) process.env.MINDOS_MCP_PORT = '8781';
+      const webPort = process.env.MINDOS_WEB_PORT;
+      const mcpPort = process.env.MINDOS_MCP_PORT;
+      console.log(cyan(`Installing MindOS as a background service (${platform})...`));
+      await runGatewayCommand('install');
+      // install() already starts the service via launchctl bootstrap + RunAtLoad=true.
+      // Do NOT call start() here — kickstart -k would kill the just-started process,
+      // causing a port-conflict race condition with KeepAlive restart loops.
+      console.log(
+        dim('  (First run may take a few minutes to install dependencies and build the app.)'),
+      );
+      const ready = await waitForHttp(Number(webPort), {
+        retries: 180,
+        intervalMs: 2000,
+        label: 'Web UI',
+        logFile: LOG_PATH,
+      });
+      if (!ready) {
+        console.error(red('\n✘ Service started but Web UI did not become ready in time.'));
+        console.error(dim('  Check logs with: mindos logs\n'));
+        process.exit(EXIT.ERROR);
+      }
+      await printStartupInfo(webPort, mcpPort);
+      // System notification
+      try {
+        if (process.platform === 'darwin') {
+          execSync(
+            `osascript -e 'display notification "http://localhost:${webPort}" with title "MindOS Ready"'`,
+            { stdio: 'ignore' },
+          );
+        } else if (process.platform === 'linux') {
+          execSync(`notify-send "MindOS Ready" "http://localhost:${webPort}"`, { stdio: 'ignore' });
+        }
+      } catch { /* notification is best-effort */ }
+      console.log(`${green('✔ MindOS is running as a background service')}`);
+      console.log(dim('  View logs:    mindos logs'));
+      console.log(dim('  Stop:         mindos gateway stop'));
+      console.log(dim('  Uninstall:    mindos gateway uninstall\n'));
+      return;
+    }
+  }
+
+  loadConfig();
+  if (!process.env.MINDOS_WEB_PORT) process.env.MINDOS_WEB_PORT = '3456';
+  if (!process.env.MINDOS_MCP_PORT) process.env.MINDOS_MCP_PORT = '8781';
+  const webPort = process.env.MINDOS_WEB_PORT;
+  const mcpPort = process.env.MINDOS_MCP_PORT;
+
+  // Clean up zombie processes from an abandoned GUI setup session.
+  // setup.js records a temporary port (setupPort) in config; if the user
+  // closed the browser without completing setup, that process is still
+  // running.  Kill it before we proceed.
+  // Also read config for auto-migration below (avoids double readFileSync).
+  let startupCfg = {};
+  try {
+    startupCfg = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+  } catch { /* ignore */ }
+  if (startupCfg.setupPort && Number(startupCfg.setupPort) !== Number(webPort)) {
+    killByPort(Number(startupCfg.setupPort));
+  }
+
+  // ── Auto-migrate user preferences → .mindos/user-preferences.md ────────
+  try {
+    const mr = startupCfg.mindRoot;
+    if (mr && existsSync(mr)) {
+      const mindosDir = resolve(mr, '.mindos');
+      const newPath = resolve(mindosDir, 'user-preferences.md');
+
+      if (!existsSync(newPath)) {
+        // Ensure .mindos/ directory exists
+        if (!existsSync(mindosDir)) mkdirSync(mindosDir, { recursive: true });
+
+        // Try migrate from previous locations (newest → oldest)
+        const prevPaths = [
+          resolve(mindosDir, 'user-rules.md'), // v0.6.x interim
+          resolve(mr, 'user-skill-rules.md'), // v0.5.x root
+        ];
+        let migrated = false;
+        for (const prev of prevPaths) {
+          if (existsSync(prev)) {
+            cpSync(prev, newPath);
+            unlinkSync(prev);
+            console.log(
+              `  ${green('✓')} ${dim(`Migrated ${prev.split('/').pop()} → .mindos/user-preferences.md`)}`,
+            );
+            migrated = true;
+            break;
+          }
+        }
+        if (!migrated) {
+          // Try legacy location (.agents/skills/{name}/user-rules.md)
+          const isZh = startupCfg.disabledSkills?.includes('mindos');
+          const sName = isZh ? 'mindos-zh' : 'mindos';
+          const oldPath = resolve(mr, '.agents', 'skills', sName, 'user-rules.md');
+          if (existsSync(oldPath)) {
+            cpSync(oldPath, newPath);
+            console.log(
+              `  ${green('✓')} ${dim('Migrated .agents/skills/ user-rules.md → .mindos/user-preferences.md')}`,
+            );
+          }
+        }
+      }
+    }
+  } catch { /* best-effort, don't block startup */ }
+
+  // When launched by a daemon manager (launchd/systemd), wait for ports to
+  // free instead of exiting immediately — the previous instance may still be
+  // shutting down after a restart/update.
+  const launchedByDaemon =
+    process.env.LAUNCHED_BY_LAUNCHD === '1' || !!process.env.INVOCATION_ID; /* systemd sets INVOCATION_ID */
+
+  if (launchedByDaemon) {
+    const { waitForPortFree } = await import('../lib/gateway.js');
+    const webOk = await waitForPortFree(Number(webPort), { retries: 60, intervalMs: 500 });
+    const mcpOk = await waitForPortFree(Number(mcpPort), { retries: 60, intervalMs: 500 });
+    if (!webOk || !mcpOk) {
+      console.error('Ports still in use after 30s, exiting.');
+      process.exit(EXIT.ERROR); // KeepAlive will retry after ThrottleInterval
+    }
+  } else {
+    await assertPortFree(Number(webPort), 'web');
+    await assertPortFree(Number(mcpPort), 'mcp');
+  }
+
+  process.env.MINDOS_CLI_PATH = resolve(ROOT, 'bin', 'cli.js');
+  process.env.MINDOS_NODE_BIN = process.execPath;
+  ensureAppDeps();
+  if (needsBuild()) {
+    console.log(yellow('Building MindOS (first run or new version detected)...\n'));
+    cleanNextDir();
+    execInherited('node scripts/gen-renderer-index.js', ROOT);
+    execInherited(`${NEXT_BIN} build --webpack`, resolve(ROOT, 'app'));
+    writeBuildStamp();
+  }
+
+  const { stopSyncDaemon, startSyncDaemon } = await import('../lib/sync.js');
+
+  const mcp = spawnMcp(isVerbose);
+  savePids(process.pid, mcp.pid);
+  process.on('exit', () => {
+    try { stopSyncDaemon(); } catch {}
+    clearPids();
+  });
+
+  const mindRoot = process.env.MIND_ROOT;
+  if (mindRoot) {
+    startSyncDaemon(mindRoot).catch(() => {});
+  }
+
+  await printStartupInfo(webPort, mcpPort);
+
+  // Prefer prebuilt standalone server (shipped with npm package) over next start.
+  // Standalone includes its own traced node_modules — no app/node_modules needed.
+  if (hasPrebuiltStandalone()) {
+    const standaloneServer = resolve(ROOT, '_standalone', 'server.js');
+    try {
+      execFileSync(process.execPath, [standaloneServer], {
+        cwd: resolve(ROOT, '_standalone'),
+        stdio: 'inherit',
+        env: {
+          ...process.env,
+          NODE_ENV: 'production',
+          HOSTNAME: process.env.MINDOS_WEB_HOST || '0.0.0.0',
+          PORT: webPort,
+        },
+      });
+    } catch (err) {
+      process.exit(err.status || 1);
+    }
+  } else {
+    execInherited(`${NEXT_BIN} start -p ${webPort} ${extra}`, resolve(ROOT, 'app'), {
+      HOSTNAME: process.env.MINDOS_WEB_HOST || '0.0.0.0',
+    });
+  }
+};

package/bin/commands/status.js

@@ -12,8 +12,8 @@ import { resolve } from 'node:path';
 
 export const meta = {
   name: 'status',
-  group: 'Core',
-  summary: 'Show MindOS service status overview',
+  group: 'Service',
+  summary: 'Show service status',
   usage: 'mindos status',
   examples: [
     'mindos status',

package/bin/commands/stop.js

@@ -0,0 +1,14 @@
+/**
+ * mindos stop — Stop running MindOS processes
+ */
+
+import { stopMindos } from '../lib/stop.js';
+
+export const meta = {
+  name: 'stop',
+  group: 'Service',
+  summary: 'Stop services',
+  usage: 'mindos stop',
+};
+
+export const run = () => stopMindos();

package/bin/commands/sync-cmd.js

@@ -0,0 +1,134 @@
+/**
+ * mindos sync — Cross-device knowledge base sync (git-based).
+ *
+ * Subcommands: init, now, conflicts, on, off. Default: print status.
+ */
+
+import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
+import { loadConfig } from '../lib/config.js';
+import { EXIT } from '../lib/command.js';
+
+export const meta = {
+  name: 'sync',
+  group: 'Sync',
+  summary: 'Git sync (init/now/conflicts/on/off)',
+  usage: 'mindos sync [subcommand]',
+  flags: {
+    '--remote <url>': 'Git remote URL for init',
+    '--token <token>': 'Auth token for private repo',
+    '--branch <name>': 'Git branch (default: main)',
+    '--json': 'Output as JSON',
+  },
+  examples: [
+    'mindos sync',
+    'mindos sync init --remote https://github.com/user/repo.git',
+    'mindos sync now',
+    'mindos sync conflicts',
+    'mindos sync on',
+    'mindos sync off',
+  ],
+};
+
+export const run = async (args, flags) => {
+  const sub = args[0];
+  loadConfig();
+  const mindRoot = process.env.MIND_ROOT;
+
+  const {
+    initSync,
+    getSyncStatus,
+    manualSync,
+    listConflicts,
+    setSyncEnabled,
+    stopSyncDaemon,
+  } = await import('../lib/sync.js');
+
+  if (sub === 'init') {
+    // Flags are already parsed by parseArgs into flags
+    const nonInteractive = flags['non-interactive'] === true;
+
+    if (nonInteractive) {
+      await initSync(mindRoot, {
+        nonInteractive: true,
+        remote: typeof flags.remote === 'string' ? flags.remote : '',
+        token: typeof flags.token === 'string' ? flags.token : '',
+        branch: (typeof flags.branch === 'string' ? flags.branch : '') || 'main',
+      });
+    } else {
+      await initSync(mindRoot);
+    }
+    return;
+  }
+
+  if (sub === 'now') {
+    try {
+      console.log(dim('Pulling...'));
+      await manualSync(mindRoot);
+      console.log(green('✔ Sync complete'));
+    } catch (err) {
+      console.error(red(err.message));
+      process.exit(EXIT.ERROR);
+    }
+    return;
+  }
+
+  if (sub === 'conflicts') {
+    await listConflicts(mindRoot);
+    return;
+  }
+
+  if (sub === 'on') {
+    await setSyncEnabled(true);
+    return;
+  }
+
+  if (sub === 'off') {
+    await setSyncEnabled(false);
+    await stopSyncDaemon();
+    return;
+  }
+
+  // Unknown subcommand check
+  if (sub) {
+    const validSubs = ['init', 'now', 'conflicts', 'on', 'off'];
+    if (!validSubs.includes(sub)) {
+      console.error(red(`Unknown sync subcommand: ${sub}`));
+      console.error(dim(`Available: ${validSubs.join(' | ')}`));
+      process.exit(EXIT.ARGS);
+    }
+  }
+
+  // default: sync status
+  const status = await getSyncStatus(mindRoot);
+
+  if (flags.json) {
+    console.log(JSON.stringify(status, null, 2));
+    return;
+  }
+
+  if (!status.enabled) {
+    console.log(`\n${bold('Sync Status')}`);
+    console.log(dim('  Not configured. Run `mindos sync init` to set up.\n'));
+    return;
+  }
+  const ago = status.lastSync
+    ? (() => {
+        const diff = Date.now() - new Date(status.lastSync).getTime();
+        if (diff < 60000) return 'just now';
+        if (diff < 3600000) return `${Math.floor(diff / 60000)} minutes ago`;
+        return `${Math.floor(diff / 3600000)} hours ago`;
+      })()
+    : 'never';
+
+  console.log(`\n${bold('Sync Status')}`);
+  console.log(`  ${dim('Provider:')}    ${cyan(`${status.provider} (${status.remote})`)}`);
+  console.log(`  ${dim('Branch:')}      ${cyan(status.branch)}`);
+  console.log(`  ${dim('Last sync:')}   ${ago}`);
+  console.log(`  ${dim('Unpushed:')}    ${status.unpushed} commits`);
+  console.log(`  ${dim('Conflicts:')}   ${status.conflicts.length ? yellow(`${status.conflicts.length} file(s)`) : green('none')}`);
+  console.log(`  ${dim('Auto-sync:')}   ${green('● enabled')} ${dim(`(commit: ${status.autoCommitInterval}s, pull: ${status.autoPullInterval / 60}min)`)}`);
+  if (status.lastError) {
+    console.log(`  ${dim('Last error:')}  ${red(status.lastError)}`);
+  }
+  console.log();
+};

package/bin/commands/token.js

@@ -0,0 +1,98 @@
+/**
+ * mindos token — Show auth token and MCP config snippet
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { CONFIG_PATH } from '../lib/constants.js';
+import { bold, dim, cyan, red } from '../lib/colors.js';
+import { getLocalIP } from '../lib/startup.js';
+import { MCP_AGENTS, detectAgentPresence } from '../lib/mcp-agents.js';
+import { EXIT } from '../lib/command.js';
+
+export const meta = {
+  name: 'token',
+  group: 'Connections',
+  summary: 'Show auth token and MCP config',
+  usage: 'mindos token',
+  flags: {
+    '--json': 'Output as JSON',
+  },
+  examples: [
+    'mindos token',
+    'mindos token --json',
+  ],
+};
+
+export const run = (args, flags) => {
+  if (!existsSync(CONFIG_PATH)) {
+    console.error(red('No config found. Run `mindos onboard` first.'));
+    process.exit(EXIT.ERROR);
+  }
+
+  let config = {};
+  try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+  const token = config.authToken || '';
+  if (!token) {
+    console.log(dim('No auth token set. Run `mindos onboard` to configure one.'));
+    process.exit(0);
+  }
+
+  const mcpPort = config.mcpPort || 8781;
+  const localIP = getLocalIP();
+  const localUrl = `http://localhost:${mcpPort}/mcp`;
+
+  if (flags.json) {
+    console.log(JSON.stringify({
+      token, mcpPort, localUrl,
+      remoteUrl: localIP ? `http://${localIP}:${mcpPort}/mcp` : null,
+    }, null, 2));
+    return;
+  }
+
+  const sep = dim('━'.repeat(40));
+  const snippet = (url) => JSON.stringify({
+    mcpServers: { mindos: { url, headers: { Authorization: `Bearer ${token}` } } },
+  }, null, 2);
+
+  console.log(`\n${bold('Auth token:')} ${cyan(token)}\n`);
+
+  const installed = [];
+  const others = [];
+  for (const [key, agent] of Object.entries(MCP_AGENTS)) {
+    (detectAgentPresence(key) ? installed : others).push([key, agent]);
+  }
+  const toShow = [...installed.slice(0, 8), ...others.slice(0, Math.max(0, 3 - installed.length))];
+
+  for (const [key, agent] of toShow) {
+    console.log(sep);
+    console.log(bold(agent.name));
+    console.log(dim('Install:') + ` mindos mcp install ${key} -g -y`);
+    if (agent.global) console.log(dim(`Config:  ${agent.global}`));
+    console.log(snippet(localUrl));
+    console.log();
+  }
+
+  if (localIP) {
+    console.log(sep);
+    console.log(bold('Remote MCP (other devices)'));
+    console.log(`URL: ${cyan(`http://${localIP}:${mcpPort}/mcp`)}`);
+    console.log(snippet(`http://${localIP}:${mcpPort}/mcp`));
+  }
+
+  // CLI Skill remote config
+  const webPort = config.port || 3456;
+  console.log(sep);
+  console.log(bold('CLI Skill (remote access)'));
+  console.log(dim('For agents with bash (Claude Code, Gemini CLI, Codex):'));
+  console.log('');
+  console.log(`  ${cyan('npm install -g @geminilight/mindos')}`);
+  console.log(`  ${cyan(`mindos config set url http://${localIP || 'localhost'}:${webPort}`)}`);
+  console.log(`  ${cyan(`mindos config set authToken ${token}`)}`);
+  console.log(`  ${cyan('mindos file list')}  ${dim('# verify connection')}`);
+  console.log('');
+
+  if (toShow.length < installed.length) {
+    console.log(dim(`\n  +${installed.length - toShow.length} more agents detected. Run \`mindos agent list\` to see all.`));
+  }
+  console.log(dim('\nRun `mindos onboard` to regenerate.\n'));
+};

package/bin/commands/uninstall.js

@@ -0,0 +1,154 @@
+/**
+ * mindos uninstall — interactive teardown: stop processes, remove daemon, optional config/KB, npm uninstall.
+ *
+ * Uses dynamic import for readline and gateway to limit upfront module cost.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+
+import { CONFIG_PATH, MINDOS_DIR } from '../lib/constants.js';
+import { bold, dim, cyan, green, red, yellow } from '../lib/colors.js';
+import { stopMindos } from '../lib/stop.js';
+
+export const meta = {
+  name: 'uninstall',
+  group: 'Config',
+  summary: 'Fully uninstall MindOS',
+  usage: 'mindos uninstall',
+};
+
+export const run = async () => {
+  const readline = await import('node:readline');
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+  // Buffer lines eagerly — readline.question() loses buffered lines when
+  // piped stdin delivers multiple lines at once (Node.js known behavior).
+  const lineBuffer = [];
+  let lineResolve = null;
+  rl.on('line', (line) => {
+    if (lineResolve) {
+      const r = lineResolve;
+      lineResolve = null;
+      r(line);
+    } else {
+      lineBuffer.push(line);
+    }
+  });
+  // On EOF with no pending resolve, close gracefully
+  rl.on('close', () => {
+    if (lineResolve) { lineResolve(''); lineResolve = null; }
+  });
+
+  function prompt(question) {
+    process.stdout.write(question + ' ');
+    if (lineBuffer.length > 0) return Promise.resolve(lineBuffer.shift());
+    return new Promise((resolve) => { lineResolve = resolve; });
+  }
+
+  async function confirm(question) {
+    const a = (await prompt(question + ' [y/N]')).trim().toLowerCase();
+    return a === 'y' || a === 'yes';
+  }
+
+  async function askInput(question) {
+    return (await prompt(question)).trim();
+  }
+
+  async function askPassword(question) {
+    // Mute echoed keystrokes
+    const stdout = process.stdout;
+    const origWrite = stdout.write.bind(stdout);
+    stdout.write = (chunk, ...args) => {
+      // Suppress everything except the prompt itself
+      if (typeof chunk === 'string' && chunk.includes(question)) return origWrite(chunk, ...args);
+      return true;
+    };
+    const answer = await prompt(question);
+    stdout.write = origWrite;
+    console.log(); // newline after hidden input
+    return answer.trim();
+  }
+
+  const done = () => rl.close();
+
+  console.log(`\n${bold('🗑  MindOS Uninstall')}\n`);
+  console.log('  This will:');
+  console.log(`  ${green('✓')} Stop running MindOS processes`);
+  console.log(`  ${green('✓')} Remove background service (if installed)`);
+  console.log(`  ${green('✓')} Uninstall npm package\n`);
+
+  if (!await confirm('Proceed?')) {
+    console.log(dim('\n  Aborted.\n'));
+    done();
+    return;
+  }
+
+  // 1. Stop processes
+  console.log(`\n${cyan('Stopping MindOS...')}`);
+  try { stopMindos(); } catch { /* may not be running */ }
+
+  // 2. Remove daemon (skip if platform unsupported)
+  const gateway = await import('../lib/gateway.js');
+  if (await gateway.getPlatform()) {
+    try {
+      await gateway.runGatewayCommand('uninstall');
+    } catch {
+      // Daemon may not be installed — that's fine
+    }
+  }
+
+  // Read config before potentially deleting ~/.mindos/
+  let config = {};
+  try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+  const mindRoot = config.mindRoot?.replace(/^~/, homedir());
+
+  // 3. Ask to remove ~/.mindos/
+  if (existsSync(MINDOS_DIR)) {
+    if (await confirm(`Remove config directory (${dim(MINDOS_DIR)})?`)) {
+      rmSync(MINDOS_DIR, { recursive: true, force: true });
+      console.log(`${green('✔')} Removed ${dim(MINDOS_DIR)}`);
+    } else {
+      console.log(dim(`  Kept ${MINDOS_DIR}`));
+    }
+  }
+
+  // 4. Ask to remove knowledge base (triple protection: confirm → type YES → password)
+  if (mindRoot && existsSync(mindRoot)) {
+    if (await confirm(`Remove knowledge base (${dim(mindRoot)})?`)) {
+      const typed = await askInput(`${yellow('⚠  This is irreversible.')} Type ${bold('YES')} to confirm:`);
+      if (typed === 'YES') {
+        const webPassword = config.webPassword;
+        let authorized = true;
+        if (webPassword) {
+          const pw = await askPassword('Enter web password:');
+          if (pw !== webPassword) {
+            console.log(red('  Wrong password. Knowledge base kept.'));
+            authorized = false;
+          }
+        }
+        if (authorized) {
+          rmSync(mindRoot, { recursive: true, force: true });
+          console.log(`${green('✔')} Removed ${dim(mindRoot)}`);
+        }
+      } else {
+        console.log(dim('  Knowledge base kept.'));
+      }
+    } else {
+      console.log(dim(`  Kept ${mindRoot}`));
+    }
+  }
+
+  // 5. npm uninstall -g
+  console.log(`\n${cyan('Uninstalling npm package...')}`);
+  try {
+    execSync('npm uninstall -g @geminilight/mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
+  } catch {
+    console.log(yellow('  npm uninstall failed — you may need to run manually:'));
+    console.log(dim('  npm uninstall -g @geminilight/mindos'));
+  }
+
+  console.log(`\n${green('✔ MindOS uninstalled.')}\n`);
+  done();
+};