@geminilight/mindos 0.2.1 → 0.4.0

package/bin/lib/config.js

@@ -1,7 +1,11 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { CONFIG_PATH } from './constants.js';
 
+let loaded = false;
+
 export function loadConfig() {
+  if (loaded) return;
+  loaded = true;
   if (!existsSync(CONFIG_PATH)) return;
   let config;
   try {

package/bin/lib/constants.js

@@ -11,3 +11,5 @@ export const MINDOS_DIR  = resolve(homedir(), '.mindos');
 export const LOG_PATH    = resolve(MINDOS_DIR, 'mindos.log');
 export const CLI_PATH    = resolve(__dirname, '..', 'cli.js');
 export const NODE_BIN    = process.execPath;
+export const UPDATE_CHECK_PATH = resolve(MINDOS_DIR, 'update-check.json');
+export const DEPS_STAMP  = resolve(MINDOS_DIR, 'deps-hash');

package/bin/lib/debug.js

@@ -0,0 +1,10 @@
+import { dim } from './colors.js';
+
+const enabled = process.env.MINDOS_DEBUG === '1' || process.argv.includes('--verbose');
+
+export function debug(...args) {
+  if (enabled) {
+    const ts = new Date().toISOString().slice(11, 23);
+    console.error(dim(`[${ts}]`), ...args);
+  }
+}

package/bin/lib/startup.js

@@ -3,6 +3,7 @@ import { networkInterfaces } from 'node:os';
 import { CONFIG_PATH } from './constants.js';
 import { bold, dim, cyan, green, yellow } from './colors.js';
 import { getSyncStatus } from './sync.js';
+import { checkForUpdate, printUpdateHint } from './update-check.js';
 
 export function getLocalIP() {
   try {
@@ -15,39 +16,32 @@ export function getLocalIP() {
   return null;
 }
 
-export function printStartupInfo(webPort, mcpPort) {
+export async function printStartupInfo(webPort, mcpPort) {
+  // Fire update check immediately (non-blocking)
+  const updatePromise = checkForUpdate().catch(() => null);
+
   let config = {};
   try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { /* ignore */ }
   const authToken = config.authToken || '';
   const localIP   = getLocalIP();
 
-  const auth = authToken
-    ? `,\n        "headers": { "Authorization": "Bearer ${authToken}" }`
-    : '';
-  const block = (host) =>
-    `  {\n    "mcpServers": {\n      "mindos": {\n        "url": "http://${host}:${mcpPort}/mcp"${auth}\n      }\n    }\n  }`;
-
   console.log(`\n${'─'.repeat(53)}`);
   console.log(`${bold('🧠 MindOS is starting')}\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`)}`);
   if (localIP) console.log(`             ${cyan(`http://${localIP}:${mcpPort}/mcp`)}`);
-  if (localIP) console.log(dim(`\n  💡 Running on a remote server? Open the Network URL (${localIP}) in your browser,\n     or use SSH port forwarding: ssh -L ${webPort}:localhost:${webPort} user@${localIP}`));
-  console.log();
-  console.log(bold('Configure MCP in your Agent:'));
-  console.log(dim('  Local (same machine):'));
-  console.log(block('localhost'));
-  if (localIP) {
-    console.log(dim('\n  Remote (other device):'));
-    console.log(block(localIP));
-  }
+
   if (authToken) {
-    console.log(`\n  🔑 ${bold('Auth token:')} ${cyan(authToken)}`);
-    console.log(dim('  Run `mindos token` anytime to view it again'));
+    const maskedToken = authToken.length > 8 ? authToken.slice(0, 8) + '····' : (authToken.length > 4 ? authToken.slice(0, 4) + '····' : '····');
+    console.log(`  ${green('●')} Auth     ${cyan(maskedToken)}  ${dim('(run `mindos token` for full config)')}`);
   }
-  console.log(dim('\n  Install Skills (optional):'));
-  console.log(dim('  npx skills add https://github.com/GeminiLight/MindOS --skill mindos -g -y'));
+
+  // MCP quick-connect hint
+  console.log(`\n  ${dim('Quick connect:')}  ${cyan('mindos mcp install claude-code -g -y')}`);
+  console.log(`  ${dim('Full config:')}    ${cyan('mindos token')}`);
+
+  if (localIP) console.log(dim(`\n  💡 Remote? SSH port forwarding: ssh -L ${webPort}:localhost:${webPort} -L ${mcpPort}:localhost:${mcpPort} user@${localIP}`));
 
   // Sync status
   const mindRoot = config.mindRoot;
@@ -70,5 +64,12 @@ export function printStartupInfo(webPort, mcpPort) {
     } catch { /* sync check is best-effort */ }
   }
 
+  // Wait for update check result (max 4s, then give up)
+  const latestVersion = await Promise.race([
+    updatePromise,
+    new Promise(r => setTimeout(() => r(null), 4000)),
+  ]);
+  if (latestVersion) printUpdateHint(latestVersion);
+
   console.log(`${'─'.repeat(53)}\n`);
 }

package/bin/lib/stop.js

@@ -1,13 +1,51 @@
 import { execSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { green, yellow, dim } from './colors.js';
 import { loadPids, clearPids } from './pid.js';
+import { CONFIG_PATH } from './constants.js';
+
+/**
+ * Kill processes listening on the given port.
+ * Returns number of processes killed.
+ */
+function killByPort(port) {
+  let killed = 0;
+  try {
+    const output = execSync(`lsof -ti :${port} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+    if (output) {
+      for (const p of output.split('\n')) {
+        const pid = Number(p);
+        if (pid > 0) {
+          try { process.kill(pid, 'SIGTERM'); killed++; } catch {}
+        }
+      }
+    }
+  } catch {
+    // lsof not available or no processes found
+  }
+  return killed;
+}
 
 export function stopMindos() {
   const pids = loadPids();
   if (!pids.length) {
-    console.log(yellow('No PID file found, trying pattern-based stop...'));
-    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 {}
+    console.log(yellow('No PID file found, trying port-based stop...'));
+    // Read ports from config
+    let webPort = '3000', mcpPort = '8787';
+    try {
+      const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+      if (config.port) webPort = String(config.port);
+      if (config.mcpPort) mcpPort = String(config.mcpPort);
+    } catch {}
+    let stopped = 0;
+    for (const port of [webPort, mcpPort]) {
+      stopped += killByPort(port);
+    }
+    if (stopped === 0) {
+      // Fallback: pkill 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 {}
+    }
     console.log(green('\u2714 Done'));
     return;
   }

package/bin/lib/sync.js

@@ -139,52 +139,66 @@ let activePullInterval = null;
 /**
  * Interactive sync init — configure remote git repo
  */
-export async function initSync(mindRoot) {
+export async function initSync(mindRoot, opts = {}) {
   if (!mindRoot) { console.error(red('No mindRoot configured.')); process.exit(1); }
 
-  const readline = await import('node:readline');
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const ask = (q) => new Promise(r => rl.question(q, r));
+  const nonInteractive = opts.nonInteractive || false;
+  let remoteUrl = opts.remote || '';
+  let token = opts.token || '';
+  let branch = opts.branch || 'main';
 
-  // 1. Ensure git repo
-  if (!isGitRepo(mindRoot)) {
-    console.log(dim('Initializing git repository...'));
-    execSync('git init', { cwd: mindRoot, stdio: 'inherit' });
-    execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }).toString();
-  }
+  if (nonInteractive) {
+    // Non-interactive mode: all params from opts
+    if (!remoteUrl) {
+      throw new Error('Remote URL is required in non-interactive mode');
+    }
+  } else {
+    // Interactive mode: prompt user
+    const readline = await import('node:readline');
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise(r => rl.question(q, r));
+
+    // 2. Remote URL
+    const currentRemote = getRemoteUrl(mindRoot);
+    const defaultUrl = currentRemote || '';
+    const urlPrompt = currentRemote
+      ? `${bold('Remote URL')} ${dim(`[${currentRemote}]`)}: `
+      : `${bold('Remote URL')} ${dim('(HTTPS or SSH)')}: `;
+    remoteUrl = (await ask(urlPrompt)).trim() || defaultUrl;
+
+    if (!remoteUrl) {
+      console.error(red('Remote URL is required.'));
+      rl.close();
+      process.exit(1);
+    }
 
-  // 2. Remote URL
-  const currentRemote = getRemoteUrl(mindRoot);
-  const defaultUrl = currentRemote || '';
-  const urlPrompt = currentRemote
-    ? `${bold('Remote URL')} ${dim(`[${currentRemote}]`)}: `
-    : `${bold('Remote URL')} ${dim('(HTTPS or SSH)')}: `;
-  let remoteUrl = (await ask(urlPrompt)).trim() || defaultUrl;
+    // 3. Token for HTTPS
+    if (remoteUrl.startsWith('https://')) {
+      token = (await ask(`${bold('Access Token')} ${dim('(GitHub PAT / GitLab PAT, leave empty if SSH)')}: `)).trim();
+    }
 
-  if (!remoteUrl) {
-    console.error(red('Remote URL is required.'));
     rl.close();
-    process.exit(1);
   }
 
-  // 3. Token for HTTPS
-  let token = '';
-  if (remoteUrl.startsWith('https://')) {
-    token = (await ask(`${bold('Access Token')} ${dim('(GitHub PAT / GitLab PAT, leave empty if SSH)')}: `)).trim();
-    if (token) {
-      // Inject token into URL for credential storage
-      const urlObj = new URL(remoteUrl);
-      urlObj.username = 'oauth2';
-      urlObj.password = token;
-      const authUrl = urlObj.toString();
-      // Configure credential helper
-      try { execSync(`git config credential.helper store`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-      // Store the credential
-      try {
-        const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
-        execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
-      } catch {}
-    }
+  // 1. Ensure git repo
+  if (!isGitRepo(mindRoot)) {
+    if (!nonInteractive) console.log(dim('Initializing git repository...'));
+    execSync('git init', { cwd: mindRoot, stdio: 'pipe' });
+    try { execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+  }
+
+  // Handle token for HTTPS
+  if (token && remoteUrl.startsWith('https://')) {
+    const urlObj = new URL(remoteUrl);
+    urlObj.username = 'oauth2';
+    urlObj.password = token;
+    // Configure credential helper
+    try { execSync(`git config credential.helper store`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    // Store the credential
+    try {
+      const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
+      execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
+    } catch {}
   }
 
   // 4. Set remote
@@ -195,50 +209,48 @@ export async function initSync(mindRoot) {
   }
 
   // 5. Test connection
-  console.log(dim('Testing connection...'));
+  if (!nonInteractive) console.log(dim('Testing connection...'));
   try {
-    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe' });
-    console.log(green('✔ Connection successful'));
+    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe', timeout: 15000 });
+    if (!nonInteractive) console.log(green('✔ Connection successful'));
   } catch {
+    const errMsg = 'Remote not reachable — check URL and credentials';
+    if (nonInteractive) throw new Error(errMsg);
     console.error(red('✘ Could not connect to remote. Check your URL and credentials.'));
-    rl.close();
     process.exit(1);
   }
 
-  rl.close();
-
   // 6. Save sync config
   const syncConfig = {
     enabled: true,
     provider: 'git',
     remote: 'origin',
-    branch: getBranch(mindRoot),
+    branch: branch || getBranch(mindRoot),
     autoCommitInterval: 30,
     autoPullInterval: 300,
   };
   saveSyncConfig(syncConfig);
-  console.log(green('✔ Sync configured'));
+  if (!nonInteractive) console.log(green('✔ Sync configured'));
 
   // 7. First sync: pull if remote has content, push otherwise
   try {
     const refs = gitExec('git ls-remote --heads origin', mindRoot);
     if (refs) {
-      console.log(dim('Pulling from remote...'));
+      if (!nonInteractive) console.log(dim('Pulling from remote...'));
       try {
-        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: 'inherit' });
+        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit' });
       } catch {
-        // Might fail if empty or conflicts — that's fine for initial setup
-        console.log(yellow('Pull completed with warnings. Check for conflicts.'));
+        if (!nonInteractive) console.log(yellow('Pull completed with warnings. Check for conflicts.'));
       }
     } else {
-      console.log(dim('Pushing to remote...'));
+      if (!nonInteractive) console.log(dim('Pushing to remote...'));
       autoCommitAndPush(mindRoot);
     }
   } catch {
-    console.log(dim('Performing initial push...'));
+    if (!nonInteractive) console.log(dim('Performing initial push...'));
     autoCommitAndPush(mindRoot);
   }
-  console.log(green('✔ Initial sync complete\n'));
+  if (!nonInteractive) console.log(green('✔ Initial sync complete\n'));
 }
 
 /**

package/bin/lib/update-check.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { ROOT, UPDATE_CHECK_PATH } from './constants.js';
+import { bold, dim, cyan, yellow } from './colors.js';
+
+const TTL_MS = 24 * 60 * 60 * 1000; // 24 hours
+
+const REGISTRIES = [
+  'https://registry.npmmirror.com/@geminilight/mindos/latest',
+  'https://registry.npmjs.org/@geminilight/mindos/latest',
+];
+
+/** Simple semver "a > b" comparison (major.minor.patch only). */
+function semverGt(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return true;
+    if ((pa[i] || 0) < (pb[i] || 0)) return false;
+  }
+  return false;
+}
+
+function getCurrentVersion() {
+  try {
+    return JSON.parse(readFileSync(resolve(ROOT, 'package.json'), 'utf-8')).version;
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function readCache() {
+  try {
+    return JSON.parse(readFileSync(UPDATE_CHECK_PATH, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeCache(latestVersion) {
+  try {
+    writeFileSync(UPDATE_CHECK_PATH, JSON.stringify({
+      lastCheck: new Date().toISOString(),
+      latestVersion,
+    }), 'utf-8');
+  } catch { /* best-effort */ }
+}
+
+async function fetchLatest() {
+  for (const url of REGISTRIES) {
+    try {
+      const res = await fetch(url, { signal: AbortSignal.timeout(3000) });
+      if (res.ok) {
+        const data = await res.json();
+        return data.version;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+/**
+ * Check for updates. Returns the latest version string if an update is
+ * available, or null if up-to-date / check fails.
+ */
+export async function checkForUpdate() {
+  if (process.env.MINDOS_NO_UPDATE_CHECK === '1') return null;
+
+  const current = getCurrentVersion();
+  const cache = readCache();
+
+  // Cache hit — still fresh
+  if (cache?.lastCheck) {
+    const age = Date.now() - new Date(cache.lastCheck).getTime();
+    if (age < TTL_MS) {
+      return (cache.latestVersion && semverGt(cache.latestVersion, current))
+        ? cache.latestVersion
+        : null;
+    }
+  }
+
+  // Cache miss or expired — fetch
+  const latest = await fetchLatest();
+  if (latest) writeCache(latest);
+  return (latest && semverGt(latest, current)) ? latest : null;
+}
+
+/** Print update hint line if an update is available. */
+export function printUpdateHint(latestVersion) {
+  const current = getCurrentVersion();
+  console.log(`\n  ${yellow('⬆')}  ${bold(`MindOS v${latestVersion}`)} available ${dim(`(current: v${current})`)}.  Run ${cyan('mindos update')} to upgrade.`);
+}

package/bin/lib/utils.js

@@ -6,8 +6,8 @@ import { ROOT } from './constants.js';
 export function run(command, cwd = ROOT) {
   try {
     execSync(command, { cwd, stdio: 'inherit', env: process.env });
-  } catch {
-    process.exit(1);
+  } catch (err) {
+    process.exit(err.status || 1);
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",

package/scripts/gen-renderer-index.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// Scans app/components/renderers/*/manifest.ts and generates
+// app/lib/renderers/index.ts with auto-discovered imports.
+//
+// Run: node scripts/gen-renderer-index.js
+// Hooked into: npm run build (via prebuild)
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const renderersDir = path.resolve(__dirname, '../app/components/renderers');
+const outputFile = path.resolve(__dirname, '../app/lib/renderers/index.ts');
+
+// Scan for manifest.ts in immediate subdirectories
+const dirs = fs.readdirSync(renderersDir, { withFileTypes: true })
+  .filter(d => d.isDirectory())
+  .filter(d => fs.existsSync(path.join(renderersDir, d.name, 'manifest.ts')))
+  .map(d => d.name)
+  .sort();
+
+if (dirs.length === 0) {
+  console.error('No manifest.ts files found in', renderersDir);
+  process.exit(1);
+}
+
+// kebab-case → camelCase
+function toCamel(s) {
+  return s.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+const imports = dirs.map(dir => {
+  const varName = toCamel(dir);
+  return `import { manifest as ${varName} } from '@/components/renderers/${dir}/manifest';`;
+}).join('\n');
+
+const varNames = dirs.map(toCamel);
+
+const code = `/**
+ * AUTO-GENERATED by scripts/gen-renderer-index.js — do not edit manually.
+ * To regenerate: node scripts/gen-renderer-index.js
+ */
+import { registerRenderer } from './registry';
+${imports}
+
+const manifests = [
+  ${varNames.join(', ')},
+];
+
+for (const m of manifests) {
+  registerRenderer(m);
+}
+`;
+
+fs.writeFileSync(outputFile, code, 'utf-8');
+console.log(`Generated ${path.relative(process.cwd(), outputFile)} with ${dirs.length} renderers: ${dirs.join(', ')}`);

package/scripts/setup.js

@@ -26,7 +26,7 @@ import { homedir, tmpdir, networkInterfaces } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createInterface } from 'node:readline';
 import { pipeline } from 'node:stream/promises';
-import { execSync } from 'node:child_process';
+import { execSync, spawn } from 'node:child_process';
 import { randomBytes, createHash } from 'node:crypto';
 import { createConnection } from 'node:net';
 
@@ -41,6 +41,14 @@ const T = {
   title:          { en: '🧠 MindOS Setup', zh: '🧠 MindOS 初始化' },
   langHint:       { en: '  ← → switch language / 切换语言    ↑ ↓ navigate    Enter confirm', zh: '  ← → switch language / 切换语言    ↑ ↓ 上下切换    Enter 确认' },
 
+  // mode selection
+  modePrompt:     { en: 'Setup mode', zh: '配置方式' },
+  modeOpts:       { en: ['CLI — terminal wizard', 'GUI — browser wizard (recommended)'], zh: ['CLI — 终端向导', 'GUI — 浏览器向导（推荐）'] },
+  modeVals:       ['cli', 'gui'],
+  guiStarting:    { en: '⏳ Starting server for GUI setup...', zh: '⏳ 正在启动服务...' },
+  guiReady:       { en: (url) => `🌐 Complete setup in browser: ${url}`, zh: (url) => `🌐 在浏览器中完成配置: ${url}` },
+  guiOpenFailed:  { en: (url) => `  Could not open browser automatically. Open this URL manually:\n  ${url}`, zh: (url) => `  无法自动打开浏览器，请手动访问：\n  ${url}` },
+
   // step labels
   step:           { en: (n, total) => `Step ${n}/${total}`, zh: (n, total) => `步骤 ${n}/${total}` },
   stepTitles:     {
@@ -106,6 +114,8 @@ const T = {
   cfgKept:        { en: '✔ Keeping existing config', zh: '✔ 保留现有配置' },
   cfgKeptNote:    { en: '  Settings from this session were not saved', zh: '  本次填写的设置未保存' },
   cfgSaved:       { en: '✔ Config saved', zh: '✔ 配置已保存' },
+  cfgConfirm:     { en: 'Save this configuration?', zh: '保存此配置？' },
+  cfgAborted:     { en: '✘ Setup cancelled. Run `mindos onboard` to try again.', zh: '✘ 设置已取消。运行 `mindos onboard` 重新开始。' },
   yesNo:          { en: '[y/N]', zh: '[y/N]' },
   yesNoDefault:   { en: '[Y/n]', zh: '[Y/n]' },
   startNow:       { en: 'Start MindOS now?', zh: '现在启动 MindOS？' },
@@ -493,11 +503,95 @@ async function applyTemplate(tpl, mindDir) {
   }
 }
 
+// ── GUI Setup ─────────────────────────────────────────────────────────────────
+
+function openBrowser(url) {
+  try {
+    const platform = process.platform;
+    if (platform === 'darwin') {
+      execSync(`open "${url}"`, { stdio: 'ignore' });
+    } else if (platform === 'linux') {
+      // Check for WSL
+      const isWSL = existsSync('/proc/version') &&
+        readFileSync('/proc/version', 'utf-8').toLowerCase().includes('microsoft');
+      if (isWSL) {
+        execSync(`cmd.exe /c start "${url}"`, { stdio: 'ignore' });
+      } else {
+        execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+      }
+    } else {
+      execSync(`cmd.exe /c start "${url}"`, { stdio: 'ignore' });
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function startGuiSetup() {
+  // Ensure ~/.mindos directory exists
+  mkdirSync(MINDOS_DIR, { recursive: true });
+
+  // Read or create config, set setupPending
+  let config = {};
+  try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch { /* ignore */ }
+  config.setupPending = true;
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+
+  // Find a free port
+  const port = await findFreePort(3000);
+  if (config.port === undefined) {
+    config.port = port;
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
+  }
+  const usePort = config.port || port;
+
+  write(c.yellow(t('guiStarting') + '\n'));
+
+  // Start the server in the background
+  const cliPath = resolve(__dirname, '../bin/cli.js');
+  const child = spawn(process.execPath, [cliPath, 'start'], {
+    detached: true,
+    stdio: 'ignore',
+    env: { ...process.env, PORT: String(usePort) },
+  });
+  child.unref();
+
+  // Wait for the server to be ready
+  const { waitForHttp } = await import('../bin/lib/gateway.js');
+  const ready = await waitForHttp(usePort, { retries: 60, intervalMs: 1000, label: 'MindOS' });
+
+  if (!ready) {
+    write(c.red('\n✘ Server failed to start.\n'));
+    process.exit(1);
+  }
+
+  const url = `http://localhost:${usePort}/setup`;
+  console.log(`\n${c.green(tf('guiReady', url))}\n`);
+
+  const opened = openBrowser(url);
+  if (!opened) {
+    console.log(c.dim(tf('guiOpenFailed', url)));
+  }
+
+  process.exit(0);
+}
+
 // ── Main ──────────────────────────────────────────────────────────────────────
 
 async function main() {
   console.log(`\n${c.bold(t('title'))}\n\n${c.dim(t('langHint'))}\n`);
 
+  // ── Mode selection: CLI or GUI ───────────────────────────────────────────
+  const mode = await select('modePrompt', 'modeOpts', 'modeVals');
+
+  if (mode === 'gui') {
+    await startGuiSetup();
+    return;
+  }
+
+  // ── CLI mode continues below ─────────────────────────────────────────────
+
   // ── Early overwrite check ─────────────────────────────────────────────────
   if (existsSync(CONFIG_PATH)) {
     let existing = {};
@@ -672,6 +766,28 @@ async function main() {
     },
   };
 
+  // ── Configuration Summary & Confirmation ──────────────────────────────────
+  const maskPw = (s) => s ? '•'.repeat(Math.min(s.length, 8)) : '';
+  const maskTk = (s) => s && s.length > 8 ? s.slice(0, 8) + '····' : (s ? s.slice(0, 4) + '····' : '');
+  const sep = '━'.repeat(40);
+  write(`\n${sep}\n`);
+  write(`${c.bold(uiLang === 'zh' ? '配置摘要' : 'Configuration Summary')}\n`);
+  write(`${sep}\n`);
+  write(`  ${c.dim('Knowledge base:')}  ${mindDir}\n`);
+  write(`  ${c.dim('Web port:')}        ${webPort}\n`);
+  write(`  ${c.dim('MCP port:')}        ${mcpPort}\n`);
+  write(`  ${c.dim('Auth token:')}      ${maskTk(authToken)}\n`);
+  if (webPassword) write(`  ${c.dim('Web password:')}    ${maskPw(webPassword)}\n`);
+  write(`  ${c.dim('AI provider:')}     ${config.ai.provider}\n`);
+  write(`  ${c.dim('Start mode:')}      ${startMode}\n`);
+  write(`${sep}\n`);
+
+  const confirmSave = await askYesNoDefault('cfgConfirm');
+  if (!confirmSave) {
+    console.log(c.red(t('cfgAborted')));
+    process.exit(0);
+  }
+
   mkdirSync(MINDOS_DIR, { recursive: true });
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);