@geminilight/mindos 0.2.0 → 0.2.1

package/bin/lib/mcp-install.js

@@ -16,6 +16,141 @@ export const MCP_AGENTS = {
   'codebuddy':       { name: 'CodeBuddy',        project: null,                               global: '~/.claude-internal/.claude.json',                                                        key: 'mcpServers' },
 };
 
+// ─── Interactive select (arrow keys) ──────────────────────────────────────────
+
+/**
+ * Single select with arrow keys.
+ * ↑/↓ to move, Enter to confirm.
+ */
+async function interactiveSelect(title, options) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    const { stdin, stdout } = process;
+
+    function render() {
+      // Move up to clear previous render (except first time)
+      stdout.write(`\x1b[${options.length + 1}A\x1b[J`);
+      draw();
+    }
+
+    function draw() {
+      stdout.write(`${bold(title)}\n`);
+      for (let i = 0; i < options.length; i++) {
+        const o = options[i];
+        const prefix = i === cursor ? cyan('❯') : ' ';
+        const label = i === cursor ? cyan(o.label) : o.label;
+        const hint = o.hint ? ` ${dim(`(${o.hint})`)}` : '';
+        stdout.write(`  ${prefix} ${label}${hint}\n`);
+      }
+    }
+
+    // Initial draw
+    stdout.write('\n');
+    draw();
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+
+    function onKey(key) {
+      if (key === '\x1b[A') { // up
+        cursor = (cursor - 1 + options.length) % options.length;
+        render();
+      } else if (key === '\x1b[B') { // down
+        cursor = (cursor + 1) % options.length;
+        render();
+      } else if (key === '\r' || key === '\n') { // enter
+        cleanup();
+        resolve(options[cursor]);
+      } else if (key === '\x03') { // ctrl+c
+        cleanup();
+        process.exit(0);
+      }
+    }
+
+    function cleanup() {
+      stdin.removeListener('data', onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    stdin.on('data', onKey);
+  });
+}
+
+/**
+ * Multi select with arrow keys.
+ * ↑/↓ to move, Space to toggle, A to toggle all, Enter to confirm.
+ */
+async function interactiveMultiSelect(title, options) {
+  return new Promise((resolve) => {
+    let cursor = 0;
+    const selected = new Set();
+    const { stdin, stdout } = process;
+
+    function render() {
+      stdout.write(`\x1b[${options.length + 2}A\x1b[J`);
+      draw();
+    }
+
+    function draw() {
+      stdout.write(`${bold(title)}  ${dim('(↑↓ move, Space select, A all, Enter confirm)')}\n`);
+      for (let i = 0; i < options.length; i++) {
+        const o = options[i];
+        const check = selected.has(i) ? green('✔') : dim('○');
+        const pointer = i === cursor ? cyan('❯') : ' ';
+        const label = i === cursor ? (selected.has(i) ? green(o.label) : cyan(o.label)) : (selected.has(i) ? green(o.label) : o.label);
+        const hint = o.hint ? ` ${dim(`(${o.hint})`)}` : '';
+        stdout.write(`  ${pointer} ${check} ${label}${hint}\n`);
+      }
+      const count = selected.size;
+      stdout.write(dim(`  ${count} selected\n`));
+    }
+
+    stdout.write('\n');
+    draw();
+
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding('utf-8');
+
+    function onKey(key) {
+      if (key === '\x1b[A') { // up
+        cursor = (cursor - 1 + options.length) % options.length;
+        render();
+      } else if (key === '\x1b[B') { // down
+        cursor = (cursor + 1) % options.length;
+        render();
+      } else if (key === ' ') { // space
+        if (selected.has(cursor)) selected.delete(cursor);
+        else selected.add(cursor);
+        render();
+      } else if (key === 'a' || key === 'A') { // toggle all
+        if (selected.size === options.length) selected.clear();
+        else options.forEach((_, i) => selected.add(i));
+        render();
+      } else if (key === '\r' || key === '\n') { // enter
+        cleanup();
+        const result = [...selected].sort().map(i => options[i]);
+        resolve(result);
+      } else if (key === '\x03') { // ctrl+c
+        cleanup();
+        process.exit(0);
+      }
+    }
+
+    function cleanup() {
+      stdin.removeListener('data', onKey);
+      stdin.setRawMode(false);
+      stdin.pause();
+    }
+
+    stdin.on('data', onKey);
+  });
+}
+
+// ─── Main install flow ────────────────────────────────────────────────────────
+
 export async function mcpInstall() {
   // Support both `mindos mcp install [agent] [flags]` and `mindos mcp [flags]`
   const sub = process.argv[3];
@@ -39,72 +174,65 @@ export async function mcpInstall() {
   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 choose = async (prompt, options, { defaultIdx = 0, forcePrompt = false } = {}) => {
-    if (hasYesFlag && !forcePrompt) return options[defaultIdx];
-    console.log(`\n${bold(prompt)}\n`);
-    options.forEach((o, i) => console.log(`  ${dim(`${i + 1}.`)} ${o.label} ${o.hint ? dim(`(${o.hint})`) : ''}`));
-    const ans = await ask(`\n${bold(`Enter number`)} ${dim(`[${defaultIdx + 1}]:`)} `);
-    const idx = ans.trim() === '' ? defaultIdx : parseInt(ans.trim(), 10) - 1;
-    return options[idx >= 0 && idx < options.length ? idx : defaultIdx];
-  };
 
   console.log(`\n${bold('🔌 MindOS MCP Install')}\n`);
 
-  // ── 1. agent ────────────────────────────────────────────────────────────────
-  let agentKey = agentArg;
-  if (!agentKey) {
-    const keys = Object.keys(MCP_AGENTS);
-    const picked = await choose('Which Agent would you like to configure?',
-      keys.map(k => ({ label: MCP_AGENTS[k].name, hint: k, value: k })), { forcePrompt: true });
-    agentKey = picked.value;
-  }
-
-  const agent = MCP_AGENTS[agentKey];
-  if (!agent) {
-    rl.close();
-    console.error(red(`\nUnknown agent: ${agentKey}`));
-    console.error(dim(`Supported: ${Object.keys(MCP_AGENTS).join(', ')}`));
-    process.exit(1);
-  }
+  // ── 1. agent(s) ──────────────────────────────────────────────────────────────
+  let agentKeys = agentArg ? [agentArg] : [];
 
-  // ── 2. scope (only ask if agent supports both) ───────────────────────────────
-  let isGlobal = hasGlobalFlag;
-  if (!hasGlobalFlag) {
-    if (agent.project && agent.global) {
-      const picked = await choose('Install scope?', [
-        { label: 'Project',  hint: agent.project, value: 'project' },
-        { label: 'Global',   hint: agent.global,  value: 'global'  },
-      ]);
-      isGlobal = picked.value === 'global';
+  if (agentKeys.length === 0) {
+    const keys = Object.keys(MCP_AGENTS);
+    if (hasYesFlag) {
+      // -y mode: install all
+      agentKeys = keys;
     } else {
-      isGlobal = !agent.project;
+      rl.close(); // close readline so raw mode works
+      const picked = await interactiveMultiSelect(
+        'Which Agents to configure?',
+        keys.map(k => ({ label: MCP_AGENTS[k].name, hint: k, value: k })),
+      );
+      if (picked.length === 0) {
+        console.log(dim('\nNo agents selected. Exiting.\n'));
+        process.exit(0);
+      }
+      agentKeys = picked.map(p => p.value);
     }
   }
 
-  const configPath = isGlobal ? agent.global : agent.project;
-  if (!configPath) {
-    rl.close();
-    console.error(red(`${agent.name} does not support ${isGlobal ? 'global' : 'project'} scope.`));
-    process.exit(1);
+  // Validate all keys first
+  for (const key of agentKeys) {
+    if (!MCP_AGENTS[key]) {
+      console.error(red(`\nUnknown agent: ${key}`));
+      console.error(dim(`Supported: ${Object.keys(MCP_AGENTS).join(', ')}`));
+      process.exit(1);
+    }
   }
 
-  // ── 3. transport ─────────────────────────────────────────────────────────────
+  // ── 2. shared transport (ask once, apply to all) ───────────────────────────
   let transport = transportArg;
   if (!transport) {
-    const picked = await choose('Transport type?', [
-      { label: 'stdio', hint: 'local, no server process needed (recommended)' },
-      { label: 'http',  hint: 'URL-based, use when server is running separately or remotely' },
-    ]);
-    transport = picked.label;
+    if (hasYesFlag) {
+      transport = 'stdio';
+    } else {
+      const picked = await interactiveSelect('Transport type?', [
+        { label: 'stdio', hint: 'local, no server process needed (recommended)' },
+        { label: 'http',  hint: 'URL-based, use when server is running separately or remotely' },
+      ]);
+      transport = picked.label;
+    }
   }
 
-  // ── 4. url + token (only for http) ───────────────────────────────────────────
+  // ── 3. url + token (only for http) ─────────────────────────────────────────
   let url = urlArg;
   let token = tokenArg;
 
   if (transport === 'http') {
+    // Re-open readline for text input
+    const rl2 = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask2 = (q) => new Promise(r => rl2.question(q, r));
+
     if (!url) {
-      url = hasYesFlag ? 'http://localhost:8787/mcp' : (await ask(`${bold('MCP URL')} ${dim('[http://localhost:8787/mcp]:')} `)).trim() || 'http://localhost:8787/mcp';
+      url = hasYesFlag ? 'http://localhost:8787/mcp' : (await ask2(`${bold('MCP URL')} ${dim('[http://localhost:8787/mcp]:')} `)).trim() || 'http://localhost:8787/mcp';
     }
 
     if (!token) {
@@ -112,45 +240,72 @@ export async function mcpInstall() {
       if (token) {
         console.log(dim(`  Using auth token from ~/.mindos/config.json`));
       } else if (!hasYesFlag) {
-        token = (await ask(`${bold('Auth token')} ${dim('(leave blank to skip):')} `)).trim();
+        token = (await ask2(`${bold('Auth token')} ${dim('(leave blank to skip):')} `)).trim();
       } else {
         console.log(yellow(`  Warning: no auth token found in ~/.mindos/config.json — config will have no auth.`));
         console.log(dim(`  Run \`mindos onboard\` to set one, or pass --token <token>.`));
       }
     }
-  }
 
-  rl.close();
+    rl2.close();
+  }
 
-  // ── build entry ──────────────────────────────────────────────────────────────
+  // ── 4. build entry ─────────────────────────────────────────────────────────
   const entry = transport === 'stdio'
     ? { type: 'stdio', command: 'mindos', args: ['mcp'], env: { MCP_TRANSPORT: 'stdio' } }
     : token
       ? { url, headers: { Authorization: `Bearer ${token}` } }
       : { url };
 
-  // ── read + merge existing config ─────────────────────────────────────────────
-  const absPath = expandHome(configPath);
-  let config = {};
-  if (existsSync(absPath)) {
-    try { config = JSON.parse(readFileSync(absPath, 'utf-8')); } catch {
-      console.error(red(`\nFailed to parse existing config: ${absPath}`));
-      process.exit(1);
+  // ── 5. install for each selected agent ─────────────────────────────────────
+  for (const agentKey of agentKeys) {
+    const agent = MCP_AGENTS[agentKey];
+
+    // scope
+    let isGlobal = hasGlobalFlag;
+    if (!hasGlobalFlag) {
+      if (agent.project && agent.global) {
+        if (hasYesFlag) {
+          isGlobal = false; // default to project
+        } else {
+          const picked = await interactiveSelect(`[${agent.name}] Install scope?`, [
+            { label: 'Project',  hint: agent.project, value: 'project' },
+            { label: 'Global',   hint: agent.global,  value: 'global'  },
+          ]);
+          isGlobal = picked.value === 'global';
+        }
+      } else {
+        isGlobal = !agent.project;
+      }
     }
-  }
 
-  if (!config[agent.key]) config[agent.key] = {};
-  const existed = !!config[agent.key].mindos;
-  config[agent.key].mindos = entry;
+    const configPath = isGlobal ? agent.global : agent.project;
+    if (!configPath) {
+      console.error(red(`  ${agent.name} does not support ${isGlobal ? 'global' : 'project'} scope — skipping.`));
+      continue;
+    }
 
-  // ── preview + write ──────────────────────────────────────────────────────────
-  console.log(`\n${bold('Preview:')} ${dim(absPath)}\n`);
-  console.log(dim(JSON.stringify({ [agent.key]: { mindos: entry } }, null, 2)));
+    // read + merge
+    const absPath = expandHome(configPath);
+    let config = {};
+    if (existsSync(absPath)) {
+      try { config = JSON.parse(readFileSync(absPath, 'utf-8')); } catch {
+        console.error(red(`  Failed to parse existing config: ${absPath} — skipping.`));
+        continue;
+      }
+    }
 
-  const dir = resolve(absPath, '..');
-  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+    if (!config[agent.key]) config[agent.key] = {};
+    const existed = !!config[agent.key].mindos;
+    config[agent.key].mindos = entry;
+
+    // write
+    const dir = resolve(absPath, '..');
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(absPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+
+    console.log(`${green('✔')} ${existed ? 'Updated' : 'Installed'} MindOS MCP for ${bold(agent.name)} ${dim(`→ ${absPath}`)}`);
+  }
 
-  console.log(`\n${green('\u2714')} ${existed ? 'Updated' : 'Installed'} MindOS MCP for ${bold(agent.name)}`);
-  console.log(dim(`  Config: ${absPath}\n`));
+  console.log(`\n${green('Done!')} ${agentKeys.length} agent(s) configured.\n`);
 }

package/bin/lib/startup.js

@@ -1,7 +1,8 @@
 import { readFileSync } from 'node:fs';
 import { networkInterfaces } from 'node:os';
 import { CONFIG_PATH } from './constants.js';
-import { bold, dim, cyan, green } from './colors.js';
+import { bold, dim, cyan, green, yellow } from './colors.js';
+import { getSyncStatus } from './sync.js';
 
 export function getLocalIP() {
   try {
@@ -47,5 +48,27 @@ export function printStartupInfo(webPort, mcpPort) {
   }
   console.log(dim('\n  Install Skills (optional):'));
   console.log(dim('  npx skills add https://github.com/GeminiLight/MindOS --skill mindos -g -y'));
+
+  // Sync status
+  const mindRoot = config.mindRoot;
+  if (mindRoot) {
+    try {
+      const syncStatus = getSyncStatus(mindRoot);
+      if (syncStatus.enabled) {
+        if (syncStatus.lastError) {
+          console.log(`\n  ${yellow('!')} Sync   ${yellow('error')}: ${syncStatus.lastError}`);
+        } else if (syncStatus.conflicts && syncStatus.conflicts.length > 0) {
+          console.log(`\n  ${yellow('!')} Sync   ${yellow(`${syncStatus.conflicts.length} conflict(s)`)}  ${dim('run `mindos sync conflicts` to view')}`);
+        } else {
+          const unpushed = parseInt(syncStatus.unpushed || '0', 10);
+          const extra = unpushed > 0 ? `  ${dim(`(${unpushed} unpushed)`)}` : '';
+          console.log(`\n  ${green('●')} Sync   ${green('enabled')}  ${dim(syncStatus.remote || 'origin')}${extra}`);
+        }
+      } else {
+        console.log(`\n  ${dim('○')} Sync   ${dim('not configured')}  ${dim('run `mindos sync init` to set up')}`);
+      }
+    } catch { /* sync check is best-effort */ }
+  }
+
   console.log(`${'─'.repeat(53)}\n`);
 }

package/mcp/src/index.ts

@@ -75,6 +75,23 @@ function truncate(text: string, limit = CHARACTER_LIMIT): string {
   return text.slice(0, limit) + `\n\n[... truncated at ${limit} characters. Use offset/limit params for paginated access.]`;
 }
 
+// ─── Agent operation logging ────────────────────────────────────────────────
+
+async function logOp(tool: string, params: Record<string, unknown>, result: 'ok' | 'error', message: string) {
+  try {
+    const entry = { ts: new Date().toISOString(), tool, params, result, message: message.slice(0, 200) };
+    const line = JSON.stringify(entry) + '\n';
+    // Append to .agent-log.json via the app API
+    await fetch(new URL("/api/file", BASE_URL).toString(), {
+      method: "POST",
+      headers: headers(),
+      body: JSON.stringify({ op: "append_to_file", path: ".agent-log.json", content: line }),
+    }).catch(() => {});
+  } catch {
+    // Logging should never break tool execution
+  }
+}
+
 // ─── MCP Server ──────────────────────────────────────────────────────────────
 
 const server = new McpServer({ name: "mindos-mcp-server", version: "1.0.0" });
@@ -91,8 +108,10 @@ server.registerTool("mindos_list_files", {
 }, async ({ response_format }) => {
   try {
     const json = await get("/api/files", { format: response_format });
-    return ok(typeof json.tree === "string" ? json.tree : JSON.stringify(json.tree ?? json, null, 2));
-  } catch (e) { return error(String(e)); }
+    const result = typeof json.tree === "string" ? json.tree : JSON.stringify(json.tree ?? json, null, 2);
+    logOp("mindos_list_files", { response_format }, "ok", `${result.length} chars`);
+    return ok(result);
+  } catch (e) { logOp("mindos_list_files", { response_format }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_read_file ────────────────────────────────────────────────────────
@@ -115,8 +134,9 @@ server.registerTool("mindos_read_file", {
     const header = hasMore
       ? `[Showing characters ${offset}–${offset + slice.length} of ${content.length}. Use offset=${offset + limit} for next page.]\n\n`
       : offset > 0 ? `[Showing characters ${offset}–${offset + slice.length} of ${content.length}]\n\n` : "";
+    logOp("mindos_read_file", { path }, "ok", `${content.length} chars`);
     return ok(header + slice);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_read_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_write_file ───────────────────────────────────────────────────────
@@ -131,8 +151,9 @@ server.registerTool("mindos_write_file", {
 }, async ({ path, content }) => {
   try {
     await post("/api/file", { op: "save_file", path, content });
+    logOp("mindos_write_file", { path }, "ok", `Wrote ${content.length} chars`);
     return ok(`Successfully wrote ${content.length} characters to "${path}"`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_write_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_create_file ──────────────────────────────────────────────────────
@@ -147,8 +168,9 @@ server.registerTool("mindos_create_file", {
 }, async ({ path, content }) => {
   try {
     await post("/api/file", { op: "create_file", path, content });
+    logOp("mindos_create_file", { path }, "ok", `Created ${content.length} chars`);
     return ok(`Created "${path}" (${content.length} characters)`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_create_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_delete_file ──────────────────────────────────────────────────────
@@ -163,8 +185,9 @@ server.registerTool("mindos_delete_file", {
 }, async ({ path }) => {
   try {
     await post("/api/file", { op: "delete_file", path });
+    logOp("mindos_delete_file", { path }, "ok", `Deleted "${path}"`);
     return ok(`Deleted "${path}"`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_delete_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_rename_file ──────────────────────────────────────────────────────
@@ -227,8 +250,9 @@ server.registerTool("mindos_search_notes", {
     if (modified_after) params.modified_after = modified_after;
     if (response_format) params.format = response_format;
     const json = await get("/api/search", params);
+    logOp("mindos_search_notes", { query, limit }, "ok", `Search completed`);
     return ok(truncate(JSON.stringify(json, null, 2)));
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_search_notes", { query }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_get_recent ───────────────────────────────────────────────────────
@@ -313,8 +337,9 @@ server.registerTool("mindos_append_to_file", {
 }, async ({ path, content }) => {
   try {
     await post("/api/file", { op: "append_to_file", path, content });
+    logOp("mindos_append_to_file", { path }, "ok", `Appended ${content.length} chars`);
     return ok(`Appended ${content.length} character(s) to "${path}"`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_append_to_file", { path }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_insert_after_heading ─────────────────────────────────────────────
@@ -330,8 +355,9 @@ server.registerTool("mindos_insert_after_heading", {
 }, async ({ path, heading, content }) => {
   try {
     await post("/api/file", { op: "insert_after_heading", path, heading, content });
+    logOp("mindos_insert_after_heading", { path, heading }, "ok", `Inserted after "${heading}"`);
     return ok(`Inserted content after heading "${heading}" in "${path}"`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_insert_after_heading", { path, heading }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_update_section ───────────────────────────────────────────────────
@@ -347,8 +373,9 @@ server.registerTool("mindos_update_section", {
 }, async ({ path, heading, content }) => {
   try {
     await post("/api/file", { op: "update_section", path, heading, content });
+    logOp("mindos_update_section", { path, heading }, "ok", `Updated section "${heading}"`);
     return ok(`Updated section "${heading}" in "${path}"`);
-  } catch (e) { return error(String(e)); }
+  } catch (e) { logOp("mindos_update_section", { path, heading }, "error", String(e)); return error(String(e)); }
 });
 
 // ── mindos_append_csv ───────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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/setup.js

@@ -6,7 +6,7 @@
  * Usage: npm run setup  OR  mindos onboard
  *
  * Steps:
- *   1. Choose knowledge base path → default ~/.mindos/my-mind
+ *   1. Choose knowledge base path → default ~/MindOS
  *   2. Choose template (en / zh / empty / custom) → copy to knowledge base path
  *   3. Choose ports (web + mcp) — checked for conflicts upfront
  *   4. Auth token (auto-generated or passphrase-seeded)
@@ -109,6 +109,8 @@ const T = {
   yesNo:          { en: '[y/N]', zh: '[y/N]' },
   yesNoDefault:   { en: '[Y/n]', zh: '[Y/n]' },
   startNow:       { en: 'Start MindOS now?', zh: '现在启动 MindOS？' },
+  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` 配置同步。' },
 
   // next steps (onboard — keep it minimal, details shown on `mindos start`)
   nextSteps: {
@@ -674,6 +676,15 @@ async function main() {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);
 
+  // ── Sync setup (optional) ──────────────────────────────────────────────────
+  const wantSync = await askYesNo('syncSetup');
+  if (wantSync) {
+    const { initSync } = await import('../bin/lib/sync.js');
+    await initSync(mindDir);
+  } else {
+    console.log(c.dim(t('syncLater')));
+  }
+
   const installDaemon = startMode === 'daemon' || process.argv.includes('--install-daemon');
   finish(mindDir, config.startMode, config.mcpPort, config.authToken, installDaemon);
 }

package/templates/README.md

@@ -18,7 +18,7 @@ If you need to manually initialize:
 mindos onboard
 
 # 2) Or copy a preset manually to your knowledge base directory
-cp -r templates/en ~/.mindos/my-mind
+cp -r templates/en ~/MindOS
 # then set mindRoot in ~/.mindos/config.json
 
 # 3) Start filling content from 👤 Profile (en) or 👤 画像 (zh)