@geminilight/mindos 0.6.40 → 0.6.42

package/bin/lib/sse-stream.js

@@ -0,0 +1,167 @@
+/**
+ * SSE streaming client for CLI → /api/ask
+ *
+ * Handles the text/event-stream protocol emitted by the MindOS Ask API.
+ * Supports text_delta, thinking_delta, tool_start, tool_end, done, error, status events.
+ */
+
+import { dim, cyan, red } from './colors.js';
+
+/**
+ * Stream an SSE response from /api/ask and print to stdout.
+ *
+ * @param {Response} res - fetch Response with Content-Type: text/event-stream
+ * @param {object} opts
+ * @param {boolean} [opts.showTools=true] - Show tool call / result lines
+ * @param {boolean} [opts.json=false] - Collect full output and return as object instead of printing
+ * @returns {Promise<{ text: string, toolCalls: string[], error?: string }>}
+ */
+export async function streamSSE(res, opts = {}) {
+  const { showTools = true, json = false } = opts;
+  const decoder = new TextDecoder();
+  if (!res.body) {
+    return { text: '', toolCalls: [], error: 'Empty response body' };
+  }
+  const reader = res.body.getReader();
+
+  let textBuffer = '';
+  const toolCalls = [];
+  let error = null;
+  let buffer = '';
+  let firstTextPrinted = false;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      buffer += decoder.decode(value, { stream: true });
+
+      const lines = buffer.split('\n');
+      // Keep the last incomplete line in buffer
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        if (!line.startsWith('data:')) continue;
+        const payload = line.slice(5);
+        if (!payload) continue;
+
+        let event;
+        try {
+          event = JSON.parse(payload);
+        } catch {
+          continue;
+        }
+
+        if (event.type === 'text_delta') {
+          if (!firstTextPrinted && !json) {
+            // Clear "Thinking..." spinner
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          textBuffer += event.text;
+          if (!json) process.stdout.write(event.text);
+        }
+
+        if (event.type === 'thinking_delta') {
+          // Suppress thinking in CLI output (it's internal reasoning)
+        }
+
+        if (event.type === 'tool_start' && showTools && !json) {
+          if (!firstTextPrinted) {
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          const name = event.name || 'unknown';
+          const inputSnippet = event.input
+            ? JSON.stringify(event.input).slice(0, 80)
+            : '';
+          const toolLine = `\n  ${dim('[')}${cyan('tool')}${dim(']')} ${name}${inputSnippet ? dim(': ' + inputSnippet) : ''}`;
+          process.stdout.write(toolLine);
+          toolCalls.push(name);
+        }
+
+        if (event.type === 'tool_end' && showTools && !json) {
+          const result = event.result || '';
+          const preview = typeof result === 'string'
+            ? result.slice(0, 120)
+            : JSON.stringify(result).slice(0, 120);
+          if (preview) {
+            process.stdout.write(dim('  → ' + preview));
+          }
+          process.stdout.write('\n');
+        }
+
+        if (event.type === 'status' && !json) {
+          if (!firstTextPrinted) {
+            process.stdout.write('\r\x1b[K');
+            firstTextPrinted = true;
+          }
+          process.stdout.write(dim(`  [${event.message || 'processing'}]\n`));
+        }
+
+        if (event.type === 'error') {
+          error = event.message || event.error || 'Unknown error';
+          if (!json) {
+            if (!firstTextPrinted) {
+              process.stdout.write('\r\x1b[K');
+            }
+            process.stderr.write('\n' + red('Error: ' + error) + '\n');
+          }
+        }
+
+        if (event.type === 'done') {
+          // Stream complete
+        }
+      }
+    }
+  } catch (err) {
+    if (!json && !firstTextPrinted) {
+      process.stdout.write('\r\x1b[K');
+    }
+    error = err.message || 'Stream interrupted';
+    if (!json) {
+      if (textBuffer) process.stdout.write('\n');
+      process.stderr.write(red('Error: ' + error) + '\n');
+    }
+  }
+
+  if (!json && textBuffer && !textBuffer.endsWith('\n')) {
+    process.stdout.write('\n');
+  }
+
+  return { text: textBuffer, toolCalls, error };
+}
+
+/**
+ * POST to /api/ask with proper headers and message format.
+ *
+ * @param {string} baseUrl - e.g. http://localhost:3456
+ * @param {object} body - { messages, mode, attachedFiles, maxSteps, ... }
+ * @param {string} [token] - Auth token
+ * @returns {Promise<Response>}
+ */
+export async function postAsk(baseUrl, body, token) {
+  const headers = { 'Content-Type': 'application/json' };
+  if (token) headers['Authorization'] = `Bearer ${token}`;
+
+  return fetch(`${baseUrl}/api/ask`, {
+    method: 'POST',
+    headers,
+    body: JSON.stringify(body),
+  });
+}
+
+/**
+ * Check if MindOS is running by hitting /api/health.
+ * @param {string} baseUrl
+ * @returns {Promise<boolean>}
+ */
+export async function checkHealth(baseUrl) {
+  try {
+    const res = await fetch(`${baseUrl}/api/health`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.6.40",
+  "version": "0.6.42",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -19,7 +19,7 @@
     "type": "git",
     "url": "https://github.com/GeminiLight/MindOS"
   },
-  "homepage": "https://mindos.app",
+  "homepage": "https://mindos.you",
   "bugs": {
     "url": "https://github.com/GeminiLight/MindOS/issues"
   },

package/scripts/setup.js

@@ -55,8 +55,8 @@ const T = {
   // step labels
   step:           { en: (n, total) => `Step ${n}/${total}`, zh: (n, total) => `步骤 ${n}/${total}` },
   stepTitles:     {
-    en: ['Knowledge Base', 'AI Provider', 'Ports', 'Auth Token', 'Web Password', 'Start Mode', 'Agent Tools'],
-    zh: ['知识库',         'AI 服务商',    '端口',   'Auth Token', 'Web 密码',     '启动方式',    'Agent 工具'],
+    en: ['Knowledge Base', 'AI Provider', 'Ports', 'Auth Token', 'Web Password', 'Start Mode', 'Connection Mode', 'Agent Connection'],
+    zh: ['知识库',         'AI 服务商',    '端口',   'Auth Token', 'Web 密码',     '启动方式',    '连接模式',          'Agent 连接'],
   },
 
   // path
@@ -125,20 +125,16 @@ const T = {
   syncSetup:      { en: 'Set up cross-device sync via Git?', zh: '是否配置 Git 跨设备同步？' },
   syncLater:      { en: '  → Run `mindos sync init` anytime to set up sync later.', zh: '  → 随时运行 `mindos sync init` 配置同步。' },
 
-  // mcp install step
-  mcpStepTitle:   { en: 'Agent Tools (MCP)', zh: 'Agent 工具 (MCP)' },
-  mcpStepHint:    { en: 'Select AI agents to configure with MindOS MCP (Space to toggle, A for all, Enter to confirm).\nAgents not yet installed can be pre-configured — they will work once you install the app.', zh: '选择要配置 MindOS MCP 的 AI Agent（空格切换，A 全选，Enter 确认）。\n未安装的 Agent 可以预先配置，安装应用后即可生效。' },
-  mcpInstalling:  { en: (n) => `⏳ Configuring ${n} agent(s)...`, zh: (n) => `⏳ 正在配置 ${n} 个 Agent...` },
-  mcpInstallOk:   { en: (name, path) => `  ${c.green('✔')} ${name}  ${c.dim('→ ' + path)}`, zh: (name, path) => `  ${c.green('✔')} ${name}  ${c.dim('→ ' + path)}` },
-  mcpInstallFail: { en: (name, msg) => `  ${c.red('✘')} ${name}  ${c.dim(msg)}`, zh: (name, msg) => `  ${c.red('✘')} ${name}  ${c.dim(msg)}` },
-  mcpInstallDone: { en: (n) => `✔ ${n} agent(s) configured`, zh: (n) => `✔ 已配置 ${n} 个 Agent` },
-  mcpSkipped:     { en: '  → Skipped. Run `mindos mcp install` anytime to configure agents.', zh: '  → 已跳过。随时运行 `mindos mcp install` 配置 Agent。' },
-
-  // skill install step
-  skillInstalling:  { en: (name) => `⏳ Installing Skill "${name}"...`, zh: (name) => `⏳ 正在安装 Skill "${name}"...` },
-  skillInstallOk:   { en: (name) => `  ${c.green('✔')} Skill "${name}" installed`, zh: (name) => `  ${c.green('✔')} Skill "${name}" 已安装` },
-  skillInstallFail: { en: (name, msg) => `  ${c.red('✘')} Skill "${name}" failed: ${msg}`, zh: (name, msg) => `  ${c.red('✘')} Skill "${name}" 安装失败：${msg}` },
-  skillSkipped:     { en: '  → No agents selected, skill install skipped.', zh: '  → 未选择 Agent，跳过 Skill 安装。' },
+  // mode selection step (Step 7)
+  modeSelectHint:   { en: 'Connection mode (Space to toggle, Enter to confirm):', zh: '连接模式（空格切换，Enter 确认）：' },
+  modeCli:          { en: 'CLI    Operate KB via command line', zh: 'CLI    通过命令行操作知识库' },
+  modeCliHint:      { en: 'recommended, more token-efficient', zh: '推荐，更省 token' },
+  modeMcp:          { en: 'MCP    Connect via MCP protocol', zh: 'MCP    通过 MCP 协议连接' },
+  modeMcpHint:      { en: 'optional, may consume more tokens', zh: '可选，可能消耗更多 token' },
+  modeNoneError:    { en: 'Please select at least one mode.', zh: '请至少选择一种模式。' },
+
+  // agent config install (internal, Skill concept hidden from user)
+  skillInstallFail: { en: (name, msg) => `  ${c.red('✘')} Configuration failed: ${msg}`, zh: (name, msg) => `  ${c.red('✘')} 配置失败：${msg}` },
 
   // restart prompts (re-onboard with config changes)
   restartRequired:   { en: 'Config changed. Service restart required.', zh: '配置已变更，需要重启服务。' },
@@ -151,14 +147,14 @@ const T = {
       '─────────────────────────────────────────────',
       '🚀 Setup complete! Start MindOS:\n',
       `     ${c.cyan(cmd)}`,
-      `  ${c.dim('MCP config, auth token, and skills info will be shown on startup.')}\n`,
+      `  ${c.dim('Connection details and auth token will be shown on startup.')}\n`,
       '─────────────────────────────────────────────',
     ],
     zh: (cmd) => [
       '─────────────────────────────────────────────',
       '🚀 初始化完成！启动 MindOS：\n',
       `     ${c.cyan(cmd)}`,
-      `  ${c.dim('MCP 配置、Auth token、Skills 信息将在启动后显示。')}\n`,
+      `  ${c.dim('连接信息和 Auth token 将在启动后显示。')}\n`,
       '─────────────────────────────────────────────',
     ],
   },
@@ -217,7 +213,7 @@ const tf = (key, ...args) => {
 
 // ── Step header ───────────────────────────────────────────────────────────────
 
-const TOTAL_STEPS = 7;
+const TOTAL_STEPS = 8;
 function stepHeader(n) {
   const title = T.stepTitles[uiLang][n - 1] ?? T.stepTitles.en[n - 1];
   const stepLabel = tf('step', n, TOTAL_STEPS);
@@ -598,10 +594,11 @@ function expandHomePath(p) {
   return p.startsWith('~/') ? resolve(homedir(), p.slice(2)) : p;
 }
 
-/** Parse JSONC: JSON plus line // comments and slash-star block comments (e.g. VS Code configs). */
+/** Parse JSONC: JSON plus comments (e.g. VS Code configs). Returns {} for empty input. */
 function parseJsonc(text) {
   let stripped = text.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*$)/gm, (m, g) => g ? '' : m);
   stripped = stripped.replace(/\/\*[\s\S]*?\*\//g, '');
+  if (!stripped.trim()) return {};
   return JSON.parse(stripped);
 }
 
@@ -622,14 +619,79 @@ function isAgentInstalled(agentKey) {
 }
 
 /**
- * Step 8: interactive multi-select of agents to configure, then install.
- * Uses the same interactiveMultiSelect as mcp-install.js (re-implemented inline
- * because this script uses its own raw-mode helpers).
+ * Step 7: mode selection — CLI (default-on) vs MCP (default-off).
+ * Returns { cli: boolean, mcp: boolean }.
  */
-async function runMcpInstallStep(mcpPort, authToken) {
+async function runModeSelect() {
+  const modes = [
+    { key: 'cli', label: t('modeCli'), hint: t('modeCliHint'), preselect: true },
+    { key: 'mcp', label: t('modeMcp'), hint: t('modeMcpHint'), preselect: false },
+  ];
+
+  return new Promise((resolve) => {
+    let cursor = 0;
+    const chosen = new Set(modes.map((m, i) => m.preselect ? i : -1).filter(i => i >= 0));
+
+    const render = (first = false, errMsg = '') => {
+      if (!first) write(`\x1b[${modes.length + (errMsg ? 3 : 2)}A\x1b[J`);
+      write(`${c.bold(t('modeSelectHint'))}\n`);
+      for (let i = 0; i < modes.length; i++) {
+        const m = modes[i];
+        const check   = chosen.has(i) ? c.green('✔') : c.dim('○');
+        const pointer = i === cursor  ? c.cyan('❯') : ' ';
+        const label   = i === cursor  ? (chosen.has(i) ? c.green(m.label) : c.cyan(m.label)) : (chosen.has(i) ? c.green(m.label) : m.label);
+        write(`  ${pointer} ${check} ${label}  ${c.dim('(' + m.hint + ')')}\n`);
+      }
+      if (errMsg) {
+        write(`  ${c.yellow('⚠ ' + errMsg)}\n`);
+      }
+      write(c.dim(`  ${chosen.size} ${uiLang === 'zh' ? '已选' : 'selected'}\n`));
+    };
+
+    write('\n');
+    render(true);
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    const onKey = (key) => {
+      if (key === '\x03') { cleanup(); process.exit(1); }
+      if (key === `${ESC}[A`) { cursor = (cursor - 1 + modes.length) % modes.length; render(); }
+      else if (key === `${ESC}[B`) { cursor = (cursor + 1) % modes.length; render(); }
+      else if (key === ' ') {
+        if (chosen.has(cursor)) chosen.delete(cursor); else chosen.add(cursor);
+        render();
+      } else if (key === '\r' || key === '\n') {
+        if (chosen.size === 0) {
+          render(false, t('modeNoneError'));
+          return;
+        }
+        cleanup();
+        resolve({
+          cli: chosen.has(0),
+          mcp: chosen.has(1),
+        });
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    process.stdin.on('data', onKey);
+  });
+}
+
+/**
+ * Agent multi-select UI — shared by both CLI-only and MCP modes.
+ * Returns array of selected agent keys.
+ */
+async function runAgentSelect() {
   const keys = Object.keys(MCP_AGENTS);
 
-  // Build options with installed/detected status shown as hint
   const options = keys.map(k => {
     const installed = isAgentInstalled(k);
     const present = detectAgentPresence(k);
@@ -641,89 +703,82 @@ async function runMcpInstallStep(mcpPort, authToken) {
     };
   });
 
-  // Sort: configured > detected > not found (stable within each group)
   options.sort((a, b) => {
     const rank = (o) => o.hint.includes('configured') || o.hint.includes('已配置') ? 0 : o.preselect ? 1 : 2;
     return rank(a) - rank(b);
   });
 
-  // Multi-select using raw mode
-  const selected = await (async () => {
-    return new Promise((resolveSelected) => {
-      let cursor = 0;
-      const chosen = new Set(options.map((o, i) => o.preselect ? i : -1).filter(i => i >= 0));
-
-      const render = (first = false) => {
-        if (!first) write(`\x1b[${options.length + 2}A\x1b[J`);
-        write(`${c.bold(uiLang === 'zh' ? '选择 Agent：' : 'Select agents:')}  ${c.dim(uiLang === 'zh' ? '(↑↓ 移动  空格 切换  D 已检测  A 全选  Enter 确认)' : '(↑↓ move  Space toggle  D detected  A all  Enter confirm)')}\n`);
-        for (let i = 0; i < options.length; i++) {
-          const o = options[i];
-          const check   = chosen.has(i) ? c.green('✔') : c.dim('○');
-          const pointer = i === cursor  ? c.cyan('❯') : ' ';
-          const label   = i === cursor  ? (chosen.has(i) ? c.green(o.label) : c.cyan(o.label)) : (chosen.has(i) ? c.green(o.label) : o.label);
-          write(`  ${pointer} ${check} ${label}  ${c.dim('(' + o.hint + ')')}\n`);
-        }
-        write(c.dim(`  ${chosen.size} ${uiLang === 'zh' ? '已选' : 'selected'}\n`));
-      };
+  const selected = await new Promise((resolveSelected) => {
+    let cursor = 0;
+    const chosen = new Set(options.map((o, i) => o.preselect ? i : -1).filter(i => i >= 0));
+
+    const render = (first = false) => {
+      if (!first) write(`\x1b[${options.length + 2}A\x1b[J`);
+      write(`${c.bold(uiLang === 'zh' ? '选择 Agent：' : 'Select agents:')}  ${c.dim(uiLang === 'zh' ? '(↑↓ 移动  空格 切换  D 已检测  A 全选  Enter 确认)' : '(↑↓ move  Space toggle  D detected  A all  Enter confirm)')}\n`);
+      for (let i = 0; i < options.length; i++) {
+        const o = options[i];
+        const check   = chosen.has(i) ? c.green('✔') : c.dim('○');
+        const pointer = i === cursor  ? c.cyan('❯') : ' ';
+        const label   = i === cursor  ? (chosen.has(i) ? c.green(o.label) : c.cyan(o.label)) : (chosen.has(i) ? c.green(o.label) : o.label);
+        write(`  ${pointer} ${check} ${label}  ${c.dim('(' + o.hint + ')')}\n`);
+      }
+      write(c.dim(`  ${chosen.size} ${uiLang === 'zh' ? '已选' : 'selected'}\n`));
+    };
 
-      write('\n');
-      render(true);
-
-      process.stdin.setRawMode(true);
-      process.stdin.resume();
-      process.stdin.setEncoding('utf8');
-
-      const onKey = (key) => {
-        if (key === '\x03') { cleanup(); process.exit(1); }
-        if (key === `${ESC}[A`) { cursor = (cursor - 1 + options.length) % options.length; render(); }
-        else if (key === `${ESC}[B`) { cursor = (cursor + 1) % options.length; render(); }
-        else if (key === ' ') {
-          if (chosen.has(cursor)) chosen.delete(cursor); else chosen.add(cursor);
-          render();
-        } else if (key === 'a' || key === 'A') {
-          if (chosen.size === options.length) chosen.clear();
-          else options.forEach((_, i) => chosen.add(i));
-          render();
-        } else if (key === 'd' || key === 'D') {
-          // Select only detected/configured agents
-          chosen.clear();
-          options.forEach((o, i) => { if (o.preselect) chosen.add(i); });
-          render();
-        } else if (key === '\r' || key === '\n') {
-          cleanup();
-          resolveSelected([...chosen].sort().map(i => options[i].value));
-        }
-      };
+    write('\n');
+    render(true);
+
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.setEncoding('utf8');
+
+    const onKey = (key) => {
+      if (key === '\x03') { cleanup(); process.exit(1); }
+      if (key === `${ESC}[A`) { cursor = (cursor - 1 + options.length) % options.length; render(); }
+      else if (key === `${ESC}[B`) { cursor = (cursor + 1) % options.length; render(); }
+      else if (key === ' ') {
+        if (chosen.has(cursor)) chosen.delete(cursor); else chosen.add(cursor);
+        render();
+      } else if (key === 'a' || key === 'A') {
+        if (chosen.size === options.length) chosen.clear();
+        else options.forEach((_, i) => chosen.add(i));
+        render();
+      } else if (key === 'd' || key === 'D') {
+        chosen.clear();
+        options.forEach((o, i) => { if (o.preselect) chosen.add(i); });
+        render();
+      } else if (key === '\r' || key === '\n') {
+        cleanup();
+        resolveSelected([...chosen].sort().map(i => options[i].value));
+      }
+    };
 
-      const cleanup = () => {
-        process.stdin.removeListener('data', onKey);
-        process.stdin.setRawMode(false);
-        process.stdin.pause();
-      };
+    const cleanup = () => {
+      process.stdin.removeListener('data', onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
 
-      process.stdin.on('data', onKey);
-    });
-  })();
+    process.stdin.on('data', onKey);
+  });
 
   if (selected.length === 0) {
-    write(c.dim(t('mcpSkipped') + '\n'));
-    return [];
+    write(c.dim(uiLang === 'zh' ? '  → 未选择 Agent。\n' : '  → No agents selected.\n'));
   }
+  return selected;
+}
 
-  write('\n' + c.dim(tf('mcpInstalling', selected.length) + '\n'));
-
-  // stdio entry (same as mcp-install.js)
+/**
+ * Write MCP config into selected agents' config files.
+ * Agent selection is handled separately by runAgentSelect().
+ */
+function installMcpConfig(selected, mcpPort, authToken) {
   const entry = { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } };
-  let okCount = 0;
 
   for (const agentKey of selected) {
     const agent = MCP_AGENTS[agentKey];
-    // prefer global scope; fall back to project
     const cfgPath = agent.global || agent.project;
-    if (!cfgPath) {
-      write(tf('mcpInstallFail', agent.name, 'no config path') + '\n');
-      continue;
-    }
+    if (!cfgPath) continue;
     const abs = expandHomePath(cfgPath);
     try {
       let config = {};
@@ -733,15 +788,8 @@ async function runMcpInstallStep(mcpPort, authToken) {
       const dir = resolve(abs, '..');
       if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
       writeFileSync(abs, JSON.stringify(config, null, 2) + '\n', 'utf-8');
-      write(tf('mcpInstallOk', agent.name, cfgPath) + '\n');
-      okCount++;
-    } catch (err) {
-      write(tf('mcpInstallFail', agent.name, String(err)) + '\n');
-    }
+    } catch { /* logged by caller via agent count */ }
   }
-
-  console.log(`\n${c.green(tf('mcpInstallDone', okCount))}`);
-  return selected;
 }
 
 /* ── Skill auto-install ────────────────────────────────────────────────────── */
@@ -758,20 +806,15 @@ const SKILL_UNSUPPORTED = new Set([]);
  * @param {string[]} selectedAgents - MCP agent keys from the multi-select step
  */
 function runSkillInstallStep(template, selectedAgents) {
-  if (!selectedAgents || selectedAgents.length === 0) {
-    write(c.dim(t('skillSkipped') + '\n'));
-    return;
-  }
+  if (!selectedAgents || selectedAgents.length === 0) return true;
 
   const skillName = template === 'zh' ? 'mindos-zh' : 'mindos';
   const localSource = resolve(ROOT, 'skills');
   const githubSource = 'GeminiLight/MindOS';
 
-  // Filter to non-universal, skill-capable agents
   const additionalAgents = selectedAgents
     .flatMap((key) => {
       if (SKILL_UNSUPPORTED.has(key)) return [];
-      // Keep backward-compatibility for non-MCP universal keys.
       if (UNIVERSAL_AGENTS.has(key)) return [];
       const reg = SKILL_AGENT_REGISTRY[key];
       if (!reg) return [key];
@@ -780,18 +823,13 @@ function runSkillInstallStep(template, selectedAgents) {
       return [reg.skillAgentName || key];
     });
 
-  // Each agent needs its own -a flag (skills CLI does NOT accept comma-separated)
   const agentFlags = additionalAgents.length > 0
     ? additionalAgents.map(a => `-a ${a}`).join(' ')
     : '-a universal';
 
-  // Try GitHub source first, fall back to local path
   const sources = [githubSource, localSource];
 
-  write(tf('skillInstalling', skillName) + '\n');
-
   for (const source of sources) {
-    // Quote local paths for shell safety
     const quotedSource = /[/\\]/.test(source) ? `"${source}"` : source;
     const cmd = `npx skills add ${quotedSource} --skill ${skillName} ${agentFlags} -g -y`;
     try {
@@ -801,12 +839,11 @@ function runSkillInstallStep(template, selectedAgents) {
         env: { ...process.env, NODE_ENV: 'production' },
         stdio: 'pipe',
       });
-      write(tf('skillInstallOk', skillName) + '\n');
-      return;
+      return true;
     } catch { /* try next source */ }
   }
 
-  write(tf('skillInstallFail', skillName, 'All sources failed') + '\n');
+  return false;
 }
 
 // ── GUI Setup ─────────────────────────────────────────────────────────────────
@@ -1230,17 +1267,42 @@ async function main() {
   // ── Skill rules are now built into SKILL.md — no install needed ──────────
   // .mindos/user-preferences.md will be created on first preference capture or via `mindos init-skills`.
 
-  // ── Step 7: MCP Agent Install ──────────────────────────────────────────────
+  // ── Step 7: Connection Mode ─────────────────────────────────────────────────
   write('\n');
   stepHeader(7);
-  write(c.dim(tf('mcpStepHint') + '\n\n'));
+  const modes = await runModeSelect();
 
-  const selectedAgents = await runMcpInstallStep(mcpPort, authToken);
+  // ── Step 8: Agent Connection ────────────────────────────────────────────────
+  write('\n');
+  stepHeader(8);
+  const selectedAgents = await runAgentSelect();
 
-  // ── Skill auto-install ────────────────────────────────────────────────────
-  if (selectedAgents && selectedAgents.length > 0) {
-    write('\n');
-    runSkillInstallStep(selectedTemplate, selectedAgents);
+  if (selectedAgents.length > 0) {
+    const agentCount = selectedAgents.length;
+    write('\n' + c.dim(uiLang === 'zh'
+      ? `  正在为 ${agentCount} 个 Agent 配置连接…`
+      : `  Configuring connection for ${agentCount} agent${agentCount > 1 ? 's' : ''}…`) + '\n');
+
+    if (modes.mcp) {
+      installMcpConfig(selectedAgents, mcpPort, authToken);
+    }
+    const skillOk = runSkillInstallStep(selectedTemplate, selectedAgents);
+
+    if (skillOk) {
+      write(c.green(uiLang === 'zh'
+        ? `  ✔ ${agentCount} 个 Agent 已配置完成\n`
+        : `  ✔ ${agentCount} agent${agentCount > 1 ? 's' : ''} configured\n`));
+    } else {
+      write(c.yellow(uiLang === 'zh'
+        ? `  ⚠ ${agentCount} 个 Agent 配置部分完成，CLI 指令文档安装失败\n`
+        : `  ⚠ ${agentCount} agent${agentCount > 1 ? 's' : ''} partially configured — CLI guide install failed\n`));
+    }
+
+    if (!modes.mcp) {
+      write(c.dim(uiLang === 'zh'
+        ? '  → 如需启用 MCP 模式，随时运行 `mindos mcp install`。\n'
+        : '  → To enable MCP mode later, run `mindos mcp install`.\n'));
+    }
   }
 
   // ── Sync setup (optional) ──────────────────────────────────────────────────
@@ -1252,10 +1314,38 @@ async function main() {
     console.log(c.dim(t('syncLater')));
   }
 
+  // ── Register CLI globally if not already in PATH ────────────────────────────
+  ensureCliInPath();
+
   const installDaemon = startMode === 'daemon' || process.argv.includes('--install-daemon');
   finish(mindDir, config.startMode, config.mcpPort, config.authToken, installDaemon, needsRestart, resumeCfg.port ?? 3456);
 }
 
+function ensureCliInPath() {
+  try {
+    execSync('command -v mindos', { stdio: 'ignore' });
+    return; // already in PATH (npm -g install or previous link)
+  } catch { /* not found */ }
+
+  // Only auto-register for source/dev installations.
+  // Desktop (Electron) manages its own process; npx is ephemeral.
+  const isDesktop = !!(process.env.ELECTRON_RUN_AS_NODE || process.env.MINDOS_DESKTOP);
+  const isDevInstall = existsSync(resolve(ROOT, '.git'));
+  if (isDesktop || !isDevInstall) return;
+
+  write('\n');
+  try {
+    execSync('npm link', { cwd: ROOT, stdio: 'ignore' });
+    write(c.green(uiLang === 'zh'
+      ? '  ✔ mindos CLI 已注册到全局路径\n'
+      : '  ✔ mindos CLI registered globally\n'));
+  } catch {
+    write(c.yellow(uiLang === 'zh'
+      ? '  ⚠ 无法自动注册 CLI，请手动运行：npm link\n'
+      : '  ⚠ Could not register CLI automatically. Run manually: npm link\n'));
+  }
+}
+
 function getLocalIP() {
   for (const ifaces of Object.values(networkInterfaces())) {
     for (const iface of ifaces) {