@geminilight/mindos 0.5.14 → 0.5.16

package/bin/cli.js

@@ -29,6 +29,7 @@
  *   mindos gateway status           — show service status
  *   mindos gateway logs             — tail service logs
  *   mindos doctor                   — health check (config, ports, build, daemon)
+ *   mindos uninstall                — fully uninstall MindOS (stop, remove daemon, npm uninstall)
  *   mindos update                   — update to latest version
  *   mindos logs                     — tail service logs (~/.mindos/mindos.log)
  *   mindos config show              — print current config (API keys masked)
@@ -42,7 +43,7 @@ import { existsSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 
-import { ROOT, CONFIG_PATH, BUILD_STAMP, LOG_PATH } from './lib/constants.js';
+import { ROOT, CONFIG_PATH, BUILD_STAMP, LOG_PATH, MINDOS_DIR } from './lib/constants.js';
 import { bold, dim, cyan, green, red, yellow } from './lib/colors.js';
 import { run } from './lib/utils.js';
 import { loadConfig, getStartMode, isDaemonMode } from './lib/config.js';
@@ -242,7 +243,7 @@ const commands = {
         // 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.)'));
         console.log(dim('  Follow live progress with:  mindos logs\n'));
-        const ready = await waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
+        const ready = await waitForHttp(Number(webPort), { retries: 60, intervalMs: 2000, label: 'Web UI' });
         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'));
@@ -604,31 +605,178 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       console.log(cyan('\n  Daemon is running — restarting to apply the new version...'));
       await runGatewayCommand('stop');
       await runGatewayCommand('install');
-      // Note: 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.
-      const webPort = (() => {
-        try { return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).port ?? 3456; } catch { return 3456; }
+      // install() starts the service:
+      //   - systemd: daemon-reload + enable + start
+      //   - launchd: bootstrap (RunAtLoad=true auto-starts)
+      // Do NOT call start() again — on macOS kickstart -k would kill the
+      // just-started process, causing a port-conflict race with KeepAlive.
+      const updateConfig = (() => {
+        try { return JSON.parse(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 waitForHttp(Number(webPort), { retries: 120, intervalMs: 2000, label: 'Web UI' });
+      const ready = await waitForHttp(Number(webPort), { retries: 60, intervalMs: 2000, label: 'Web UI' });
       if (ready) {
-        console.log(green('✔ MindOS restarted and ready.\n'));
+        const localIP = getLocalIP();
+        console.log(`\n${'─'.repeat(53)}`);
+        console.log(`${green('✔')} ${bold(`MindOS updated: ${currentVersion} → ${newVersion}`)}\n`);
+        console.log(`  ${green('●')} Web UI   ${cyan(`http://localhost:${webPort}`)}`);
+        if (localIP) console.log(`             ${cyan(`http://${localIP}:${webPort}`)}`);
+        console.log(`  ${green('●')} MCP      ${cyan(`http://localhost:${mcpPort}/mcp`)}`);
+        console.log(`\n  ${dim('View changelog:')}  ${cyan('https://github.com/GeminiLight/MindOS/releases')}`);
+        console.log(`${'─'.repeat(53)}\n`);
       } else {
         console.error(red('✘ MindOS did not come back up in time. Check logs: mindos logs\n'));
         process.exit(1);
       }
     } else {
-      console.log(dim('  Run `mindos start` — it will rebuild automatically.\n'));
+      console.log(`\n${green('✔')} ${bold(`Updated: ${currentVersion} → ${newVersion}`)}`);
+      console.log(dim('  Run `mindos start` — it will rebuild automatically.'));
+      console.log(`  ${dim('View changelog:')}  ${cyan('https://github.com/GeminiLight/MindOS/releases')}\n`);
     }
   },
 
+  // ── uninstall ──────────────────────────────────────────────────────────────
+  uninstall: 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)
+    if (getPlatform()) {
+      try {
+        await 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();
+  },
+
   // ── logs ───────────────────────────────────────────────────────────────────
   logs: () => {
     ensureMindosDir();
     if (!existsSync(LOG_PATH)) {
       console.log(dim(`No log file yet at ${LOG_PATH}`));
-      console.log(dim('Logs are written when running in daemon mode (mindos start --daemon).'));
+      console.log(dim('Logs are created when starting MindOS (mindos start, mindos onboard, or daemon mode).'));
       process.exit(0);
     }
     const noFollow = process.argv.includes('--no-follow');
@@ -932,6 +1080,7 @@ ${bold('Config & Diagnostics:')}
 ${row('mindos config <subcommand>',        'View/update config (show/validate/set/unset)')}
 ${row('mindos doctor',                     'Health check (config, ports, build, daemon)')}
 ${row('mindos update',                     'Update MindOS to the latest version')}
+${row('mindos uninstall',                  'Fully uninstall MindOS (stop, remove daemon, npm uninstall)')}
 ${row('mindos logs',                       'Tail service logs (~/.mindos/mindos.log)')}
 ${row('mindos',                            'Start using mode saved in ~/.mindos/config.json')}
 `);

package/bin/lib/build.js

@@ -38,14 +38,15 @@ export function cleanNextDir() {
 }
 
 function depsHash() {
-  // Use package.json (not package-lock.json) so we don't need to ship the
-  // 560kB lock file in the npm tarball.  package.json changes whenever
-  // dependencies are added/removed/bumped, which is the only case that
-  // requires a fresh `npm install`.
+  // Hash both package.json and package-lock.json (if present) so that
+  // changes to either trigger a fresh npm install.
   const pkgPath = resolve(ROOT, 'app', 'package.json');
+  const lockPath = resolve(ROOT, 'app', 'package-lock.json');
   try {
-    const content = readFileSync(pkgPath);
-    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+    const h = createHash('sha256');
+    h.update(readFileSync(pkgPath));
+    try { h.update(readFileSync(lockPath)); } catch {}
+    return h.digest('hex').slice(0, 16);
   } catch {
     return null;
   }

package/bin/lib/gateway.js

@@ -50,8 +50,19 @@ export async function waitForPortFree(port, { retries = 30, intervalMs = 500 } =
   return !(await isPortInUse(port));
 }
 
-export async function waitForHttp(port, { retries = 120, intervalMs = 2000, label = 'service' } = {}) {
-  process.stdout.write(cyan(`  Waiting for ${label} to be ready`));
+export async function waitForHttp(port, { retries = 60, intervalMs = 2000, label = 'service' } = {}) {
+  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`;
+  };
+  const phases = [
+    { after: 0,  msg: 'installing dependencies' },
+    { after: 15, msg: 'building app' },
+    { after: 60, msg: 'still building (first run takes a while)' },
+  ];
+  let currentPhase = -1;
+
   for (let i = 0; i < retries; i++) {
     try {
       const { request } = await import('node:http');
@@ -62,12 +73,30 @@ export async function waitForHttp(port, { retries = 120, intervalMs = 2000, labe
         req.on('timeout', () => { req.destroy(); resolve(false); });
         req.end();
       });
-      if (ok) { process.stdout.write(` ${green('\u2714')}\n`); return true; }
+      if (ok) {
+        // Clear line and print success
+        process.stdout.write(`\r\x1b[K`);
+        process.stdout.write(`  ${green('\u2714')} ${label} ready ${dim(`(${elapsed()})`)}\n`);
+        return true;
+      }
     } catch { /* not ready yet */ }
-    process.stdout.write('.');
+
+    // Update phase hint
+    const secs = (Date.now() - start) / 1000;
+    const nextPhase = phases.reduce((idx, p, i) => secs >= p.after ? i : idx, -1);
+    if (nextPhase !== currentPhase) {
+      currentPhase = nextPhase;
+    }
+    const hint = currentPhase >= 0 ? phases[currentPhase].msg : '';
+
+    // Rewrite the status line in place
+    process.stdout.write(`\r\x1b[K`);
+    process.stdout.write(cyan(`  ⏳ Waiting for ${label}`) + dim(` — ${hint} (${elapsed()})`));
+
     await new Promise(r => setTimeout(r, intervalMs));
   }
-  process.stdout.write(` ${red('\u2718')}\n`);
+  process.stdout.write(`\r\x1b[K`);
+  process.stdout.write(`  ${red('\u2718')} ${label} did not start ${dim(`(${elapsed()})`)}\n`);
   return false;
 }
 
@@ -107,14 +136,15 @@ const systemd = {
     ].join('\n');
     writeFileSync(SYSTEMD_UNIT, unit, 'utf-8');
     console.log(green(`\u2714 Wrote ${SYSTEMD_UNIT}`));
-    execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
-    execSync('systemctl --user enable mindos', { stdio: 'inherit' });
-    console.log(green('\u2714 Service installed and enabled'));
+    execSync('systemctl --user daemon-reload', { stdio: ['ignore', 'inherit', 'inherit'] });
+    execSync('systemctl --user enable mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
+    execSync('systemctl --user start mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
+    console.log(green('\u2714 Service installed and started'));
   },
 
   async start() {
     rotateLogs();
-    execSync('systemctl --user start mindos', { stdio: 'inherit' });
+    execSync('systemctl --user start mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
     const ok = await waitForService(() => {
       try {
         const out = execSync('systemctl --user is-active mindos', { encoding: 'utf-8' }).trim();
@@ -123,36 +153,36 @@ const systemd = {
     });
     if (!ok) {
       console.error(red('\n\u2718 Service failed to start. Last log output:'));
-      try { execSync(`journalctl --user -u mindos -n 30 --no-pager`, { stdio: 'inherit' }); } catch {}
+      try { execSync(`journalctl --user -u mindos -n 30 --no-pager`, { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
       process.exit(1);
     }
     console.log(green('\u2714 Service started'));
   },
 
   stop() {
-    execSync('systemctl --user stop mindos', { stdio: 'inherit' });
+    execSync('systemctl --user stop mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
     console.log(green('\u2714 Service stopped'));
   },
 
   status() {
     try {
-      execSync('systemctl --user status mindos', { stdio: 'inherit' });
+      execSync('systemctl --user status mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
     } catch { /* status exits non-zero when stopped */ }
   },
 
   logs() {
-    execSync(`journalctl --user -u mindos -f`, { stdio: 'inherit' });
+    execSync(`journalctl --user -u mindos -f`, { stdio: ['ignore', 'inherit', 'inherit'] });
   },
 
   uninstall() {
     try {
-      execSync('systemctl --user disable --now mindos', { stdio: 'inherit' });
+      execSync('systemctl --user disable --now mindos', { stdio: ['ignore', 'inherit', 'inherit'] });
     } catch { /* may already be stopped */ }
     if (existsSync(SYSTEMD_UNIT)) {
       rmSync(SYSTEMD_UNIT);
       console.log(green(`\u2714 Removed ${SYSTEMD_UNIT}`));
     }
-    execSync('systemctl --user daemon-reload', { stdio: 'inherit' });
+    execSync('systemctl --user daemon-reload', { stdio: ['ignore', 'inherit', 'inherit'] });
     console.log(green('\u2714 Service uninstalled'));
   },
 };
@@ -213,7 +243,7 @@ const launchd = {
 
   async start() {
     rotateLogs();
-    execSync(`launchctl kickstart -k gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: 'inherit' });
+    execSync(`launchctl kickstart -k gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: ['ignore', 'inherit', 'inherit'] });
     const ok = await waitForService(() => {
       try {
         const out = execSync(`launchctl print gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { encoding: 'utf-8' });
@@ -222,7 +252,7 @@ const launchd = {
     });
     if (!ok) {
       console.error(red('\n\u2718 Service failed to start. Last log output:'));
-      try { execSync(`tail -n 30 ${LOG_PATH}`, { stdio: 'inherit' }); } catch {}
+      try { execSync(`tail -n 30 ${LOG_PATH}`, { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
       process.exit(1);
     }
     console.log(green('\u2714 Service started'));
@@ -238,7 +268,7 @@ const launchd = {
     } catch {}
 
     try {
-      execSync(`launchctl bootout gui/${launchctlUid()} ${LAUNCHD_PLIST}`, { stdio: 'inherit' });
+      execSync(`launchctl bootout gui/${launchctlUid()} ${LAUNCHD_PLIST}`, { stdio: ['ignore', 'inherit', 'inherit'] });
     } catch { /* may not be running */ }
 
     // launchctl bootout is async — wait for ports to actually be freed
@@ -264,19 +294,19 @@ const launchd = {
 
   status() {
     try {
-      execSync(`launchctl print gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: 'inherit' });
+      execSync(`launchctl print gui/${launchctlUid()}/${LAUNCHD_LABEL}`, { stdio: ['ignore', 'inherit', 'inherit'] });
     } catch {
       console.log(dim('Service is not running'));
     }
   },
 
   logs() {
-    execSync(`tail -f ${LOG_PATH}`, { stdio: 'inherit' });
+    execSync(`tail -f ${LOG_PATH}`, { stdio: ['ignore', 'inherit', 'inherit'] });
   },
 
   uninstall() {
     try {
-      execSync(`launchctl bootout gui/${launchctlUid()} ${LAUNCHD_PLIST}`, { stdio: 'inherit' });
+      execSync(`launchctl bootout gui/${launchctlUid()} ${LAUNCHD_PLIST}`, { stdio: ['ignore', 'inherit', 'inherit'] });
     } catch { /* may not be running */ }
     if (existsSync(LAUNCHD_PLIST)) {
       rmSync(LAUNCHD_PLIST);

package/bin/lib/stop.js

@@ -110,8 +110,8 @@ export function stopMindos(opts = {}) {
 
   if (!pids.length && portKilled === 0) {
     // Last resort: pattern match (for envs without lsof)
-    try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: 'inherit' }); } catch {}
-    try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: 'inherit' }); } catch {}
+    try { execSync('pkill -f "next start|next dev" 2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
+    try { execSync('pkill -f "mcp/src/index"       2>/dev/null || true', { stdio: ['ignore', 'inherit', 'inherit'] }); } catch {}
   }
 
   if (!pids.length) console.log(green('\u2714 Done'));

package/mcp/package.json

@@ -11,7 +11,7 @@
     "zod": "^3.23.8"
   },
   "devDependencies": {
-    "@types/node": "^25.4.0",
+    "@types/node": "^22",
     "tsx": "^4.19.0",
     "typescript": "^5"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.14",
+  "version": "0.5.16",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -57,8 +57,7 @@
     "!assets/images",
     "!mcp/node_modules",
     "!mcp/dist",
-    "!mcp/package-lock.json",
-    "!app/package-lock.json"
+    "!mcp/package-lock.json"
   ],
   "scripts": {
     "setup": "node scripts/setup.js",

package/scripts/setup.js

@@ -20,7 +20,7 @@
  *   Enter confirms
  */
 
-import { existsSync, cpSync, writeFileSync, readFileSync, mkdirSync, createWriteStream, rmSync } from 'node:fs';
+import { existsSync, cpSync, writeFileSync, readFileSync, mkdirSync, createWriteStream, rmSync, openSync } from 'node:fs';
 import { resolve, dirname, join } from 'node:path';
 import { homedir, tmpdir, networkInterfaces } from 'node:os';
 import { fileURLToPath } from 'node:url';
@@ -36,6 +36,7 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const ROOT = resolve(__dirname, '..');
 const MINDOS_DIR = resolve(homedir(), '.mindos');
 const CONFIG_PATH = resolve(MINDOS_DIR, 'config.json');
+const LOG_PATH = resolve(MINDOS_DIR, 'mindos.log');
 
 // ── i18n ─────────────────────────────────────────────────────────────────────
 
@@ -886,19 +887,34 @@ async function startGuiSetup() {
   // Pass MINDOS_WEB_PORT (not PORT) so loadConfig() won't override with the
   // config file port — this is critical when we need a temporary port.
   const cliPath = resolve(__dirname, '../bin/cli.js');
+  const logFd = openSync(LOG_PATH, 'a');
   const child = spawn(process.execPath, [cliPath, 'start'], {
     detached: true,
-    stdio: 'ignore',
+    stdio: ['ignore', logFd, logFd],
     env: { ...process.env, MINDOS_WEB_PORT: String(usePort) },
   });
   child.unref();
 
-  // Wait for the server to be ready
+  // First-time install hint
+  if (isFirstTime) {
+    write(c.dim('  First run: installing dependencies and building app (may take a few minutes)...\n'));
+  }
+
+  // Wait for the server to be ready (120s timeout)
   const { waitForHttp } = await import('../bin/lib/gateway.js');
-  const ready = await waitForHttp(usePort, { retries: 60, intervalMs: 1000, label: 'MindOS' });
+  const ready = await waitForHttp(usePort, { retries: 120, intervalMs: 1000, label: 'MindOS' });
 
   if (!ready) {
     write(c.red('\n✘ Server failed to start.\n'));
+    if (existsSync(LOG_PATH)) {
+      write(c.dim(`\n  Last log output (${LOG_PATH}):\n`));
+      try {
+        const lines = readFileSync(LOG_PATH, 'utf-8').trim().split('\n').slice(-15);
+        for (const line of lines) write(c.dim(`  ${line}\n`));
+      } catch {}
+    }
+    write(c.dim(`\n  Full logs: mindos logs\n`));
+    write(c.dim(`  Manual start: mindos start\n\n`));
     process.exit(1);
   }