@geminilight/mindos 0.1.9 → 0.2.1

package/bin/lib/sync.js

@@ -0,0 +1,367 @@
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { CONFIG_PATH, MINDOS_DIR } from './constants.js';
+import { bold, dim, cyan, green, red, yellow } from './colors.js';
+
+// ── Config helpers ──────────────────────────────────────────────────────────
+
+function loadSyncConfig() {
+  try {
+    const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    return config.sync || {};
+  } catch {
+    return {};
+  }
+}
+
+function saveSyncConfig(syncConfig) {
+  let config = {};
+  try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+  config.sync = syncConfig;
+  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+}
+
+function getMindRoot() {
+  try {
+    const config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8'));
+    return config.mindRoot;
+  } catch {
+    return null;
+  }
+}
+
+const SYNC_STATE_PATH = resolve(MINDOS_DIR, 'sync-state.json');
+
+function loadSyncState() {
+  try {
+    return JSON.parse(readFileSync(SYNC_STATE_PATH, 'utf-8'));
+  } catch {
+    return {};
+  }
+}
+
+function saveSyncState(state) {
+  if (!existsSync(MINDOS_DIR)) mkdirSync(MINDOS_DIR, { recursive: true });
+  writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+}
+
+// ── Git helpers ─────────────────────────────────────────────────────────────
+
+function isGitRepo(dir) {
+  return existsSync(resolve(dir, '.git'));
+}
+
+function gitExec(cmd, cwd) {
+  return execSync(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+}
+
+function getRemoteUrl(cwd) {
+  try {
+    return gitExec('git remote get-url origin', cwd);
+  } catch {
+    return null;
+  }
+}
+
+function getBranch(cwd) {
+  try {
+    return gitExec('git rev-parse --abbrev-ref HEAD', cwd);
+  } catch {
+    return 'main';
+  }
+}
+
+function getUnpushedCount(cwd) {
+  try {
+    return gitExec('git rev-list --count @{u}..HEAD', cwd);
+  } catch {
+    return '?';
+  }
+}
+
+// ── Core sync functions ─────────────────────────────────────────────────────
+
+function autoCommitAndPush(mindRoot) {
+  try {
+    execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
+    const status = gitExec('git status --porcelain', mindRoot);
+    if (!status) return;
+    const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+    execSync(`git commit -m "auto-sync: ${timestamp}"`, { cwd: mindRoot, stdio: 'pipe' });
+    execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+    saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
+  } catch (err) {
+    saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
+  }
+}
+
+function autoPull(mindRoot) {
+  try {
+    execSync('git pull --rebase --autostash', { cwd: mindRoot, stdio: 'pipe' });
+    saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
+  } catch {
+    // rebase conflict → abort → merge
+    try { execSync('git rebase --abort', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    try {
+      execSync('git pull --no-rebase', { cwd: mindRoot, stdio: 'pipe' });
+      saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
+    } catch {
+      // merge conflict → keep both versions
+      try {
+        const conflicts = gitExec('git diff --name-only --diff-filter=U', mindRoot).split('\n').filter(Boolean);
+        for (const file of conflicts) {
+          try {
+            const theirs = execSync(`git show :3:${file}`, { cwd: mindRoot, encoding: 'utf-8' });
+            writeFileSync(resolve(mindRoot, file + '.sync-conflict'), theirs, 'utf-8');
+          } catch {}
+          try { execSync(`git checkout --ours "${file}"`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+        }
+        execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
+        execSync('git commit -m "auto-sync: resolved conflicts (kept both versions)"', { cwd: mindRoot, stdio: 'pipe' });
+        saveSyncState({
+          ...loadSyncState(),
+          lastPull: new Date().toISOString(),
+          conflicts: conflicts.map(f => ({ file: f, time: new Date().toISOString() })),
+        });
+      } catch (err) {
+        saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
+      }
+    }
+  }
+}
+
+// ── Exported API ────────────────────────────────────────────────────────────
+
+let activeWatcher = null;
+let activePullInterval = null;
+
+/**
+ * Interactive sync init — configure remote git repo
+ */
+export async function initSync(mindRoot) {
+  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));
+
+  // 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();
+  }
+
+  // 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;
+
+  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 {}
+    }
+  }
+
+  // 4. Set remote
+  try {
+    execSync(`git remote add origin "${remoteUrl}"`, { cwd: mindRoot, stdio: 'pipe' });
+  } catch {
+    execSync(`git remote set-url origin "${remoteUrl}"`, { cwd: mindRoot, stdio: 'pipe' });
+  }
+
+  // 5. Test connection
+  console.log(dim('Testing connection...'));
+  try {
+    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe' });
+    console.log(green('✔ Connection successful'));
+  } catch {
+    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),
+    autoCommitInterval: 30,
+    autoPullInterval: 300,
+  };
+  saveSyncConfig(syncConfig);
+  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...'));
+      try {
+        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: 'inherit' });
+      } catch {
+        // Might fail if empty or conflicts — that's fine for initial setup
+        console.log(yellow('Pull completed with warnings. Check for conflicts.'));
+      }
+    } else {
+      console.log(dim('Pushing to remote...'));
+      autoCommitAndPush(mindRoot);
+    }
+  } catch {
+    console.log(dim('Performing initial push...'));
+    autoCommitAndPush(mindRoot);
+  }
+  console.log(green('✔ Initial sync complete\n'));
+}
+
+/**
+ * Start file watcher + periodic pull
+ */
+export async function startSyncDaemon(mindRoot) {
+  const config = loadSyncConfig();
+  if (!config.enabled) return null;
+  if (!mindRoot || !isGitRepo(mindRoot)) return null;
+
+  const chokidar = await import('chokidar');
+
+  // File watcher → debounced auto-commit + push
+  let commitTimer = null;
+  const watcher = chokidar.watch(mindRoot, {
+    ignored: [/(^|[/\\])\.git/, /node_modules/, /\.sync-conflict$/],
+    persistent: true,
+    ignoreInitial: true,
+  });
+  watcher.on('all', () => {
+    clearTimeout(commitTimer);
+    commitTimer = setTimeout(() => autoCommitAndPush(mindRoot), (config.autoCommitInterval || 30) * 1000);
+  });
+
+  // Periodic pull
+  const pullInterval = setInterval(() => autoPull(mindRoot), (config.autoPullInterval || 300) * 1000);
+
+  // Pull on startup
+  autoPull(mindRoot);
+
+  activeWatcher = watcher;
+  activePullInterval = pullInterval;
+
+  return { watcher, pullInterval };
+}
+
+/**
+ * Stop sync daemon
+ */
+export function stopSyncDaemon() {
+  if (activeWatcher) {
+    activeWatcher.close();
+    activeWatcher = null;
+  }
+  if (activePullInterval) {
+    clearInterval(activePullInterval);
+    activePullInterval = null;
+  }
+}
+
+/**
+ * Get current sync status
+ */
+export function getSyncStatus(mindRoot) {
+  const config = loadSyncConfig();
+  const state = loadSyncState();
+
+  if (!config.enabled) {
+    return { enabled: false };
+  }
+
+  const remote = mindRoot ? getRemoteUrl(mindRoot) : null;
+  const branch = mindRoot ? getBranch(mindRoot) : null;
+  const unpushed = mindRoot ? getUnpushedCount(mindRoot) : '?';
+
+  return {
+    enabled: true,
+    provider: config.provider || 'git',
+    remote: remote || '(not configured)',
+    branch: branch || 'main',
+    lastSync: state.lastSync || null,
+    lastPull: state.lastPull || null,
+    unpushed,
+    conflicts: state.conflicts || [],
+    lastError: state.lastError || null,
+    autoCommitInterval: config.autoCommitInterval || 30,
+    autoPullInterval: config.autoPullInterval || 300,
+  };
+}
+
+/**
+ * Manual trigger of full sync cycle
+ */
+export function manualSync(mindRoot) {
+  if (!mindRoot || !isGitRepo(mindRoot)) {
+    console.error(red('Not a git repository. Run `mindos sync init` first.'));
+    process.exit(1);
+  }
+  console.log(dim('Pulling...'));
+  autoPull(mindRoot);
+  console.log(dim('Committing & pushing...'));
+  autoCommitAndPush(mindRoot);
+  console.log(green('✔ Sync complete'));
+}
+
+/**
+ * List conflict files
+ */
+export function listConflicts(mindRoot) {
+  const state = loadSyncState();
+  const conflicts = state.conflicts || [];
+  if (!conflicts.length) {
+    console.log(green('No conflicts'));
+    return [];
+  }
+  console.log(bold(`${conflicts.length} conflict(s):\n`));
+  for (const c of conflicts) {
+    console.log(`  ${yellow('●')} ${c.file}  ${dim(c.time)}`);
+    const conflictPath = resolve(mindRoot, c.file + '.sync-conflict');
+    if (existsSync(conflictPath)) {
+      console.log(dim(`    Remote version saved: ${c.file}.sync-conflict`));
+    }
+  }
+  console.log();
+  return conflicts;
+}
+
+/**
+ * Enable/disable sync
+ */
+export function setSyncEnabled(enabled) {
+  const config = loadSyncConfig();
+  config.enabled = enabled;
+  saveSyncConfig(config);
+  console.log(enabled ? green('✔ Auto-sync enabled') : yellow('Auto-sync disabled'));
+}

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.1.9",
+  "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",
@@ -51,9 +51,13 @@
     "build": "mindos build",
     "start": "mindos start",
     "mcp": "mindos mcp",
-    "test": "cd app && npx vitest run"
+    "test": "cd app && npx vitest run",
+    "release": "bash scripts/release.sh"
   },
   "engines": {
     "node": ">=18"
+  },
+  "dependencies": {
+    "chokidar": "^5.0.0"
   }
 }

package/scripts/release.sh

@@ -0,0 +1,56 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ── Usage ────────────────────────────────────────────────────────────────
+# npm run release [patch|minor|major]   (default: patch)
+# ─────────────────────────────────────────────────────────────────────────
+
+BUMP="${1:-patch}"
+
+# 1. Ensure clean working tree
+if ! git diff --quiet || ! git diff --cached --quiet; then
+  echo "❌ Working tree is not clean. Commit or stash changes first."
+  exit 1
+fi
+
+# 2. Run tests
+echo "🧪 Running tests..."
+npm test
+echo ""
+
+# 3. Bump version (creates commit + tag automatically)
+echo "📦 Bumping version ($BUMP)..."
+npm version "$BUMP" -m "%s"
+VERSION="v$(node -p "require('./package.json').version")"
+echo "   Version: $VERSION"
+echo ""
+
+# 4. Push commit + tag
+echo "🚀 Pushing to origin..."
+git push origin main
+git push origin "$VERSION"
+echo ""
+
+# 5. Wait for CI (if gh is available)
+if command -v gh &>/dev/null; then
+  echo "⏳ Waiting for CI publish workflow..."
+  TIMEOUT=120
+  ELAPSED=0
+  RUN_ID=""
+
+  # Wait for the workflow run to appear
+  while [ -z "$RUN_ID" ] && [ "$ELAPSED" -lt 30 ]; do
+    sleep 3
+    ELAPSED=$((ELAPSED + 3))
+    RUN_ID=$(gh run list --workflow=publish-npm.yml --limit=1 --json databaseId,headBranch --jq ".[0].databaseId" 2>/dev/null || true)
+  done
+
+  if [ -n "$RUN_ID" ]; then
+    gh run watch "$RUN_ID" --exit-status && echo "✅ Published $VERSION to npm" || echo "❌ CI failed — check: gh run view $RUN_ID --log"
+  else
+    echo "⚠️  Could not find CI run. Check manually: https://github.com/GeminiLight/mindos-dev/actions"
+  fi
+else
+  echo "💡 Install 'gh' CLI to auto-watch CI status."
+  echo "   Check publish status: https://github.com/GeminiLight/mindos-dev/actions"
+fi

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)
@@ -44,8 +44,8 @@ const T = {
   // step labels
   step:           { en: (n, total) => `Step ${n}/${total}`, zh: (n, total) => `步骤 ${n}/${total}` },
   stepTitles:     {
-    en: ['Knowledge Base', 'Template', 'Ports', 'Auth Token', 'Web Password', 'AI Provider'],
-    zh: ['知识库',         '模板',     '端口',   'Auth Token', 'Web 密码',     'AI 服务商'],
+    en: ['Knowledge Base', 'Template', 'Ports', 'Auth Token', 'Web Password', 'AI Provider', 'Start Mode'],
+    zh: ['知识库',         '模板',     '端口',   'Auth Token', 'Web 密码',     'AI 服务商',    '启动方式'],
   },
 
   // path
@@ -97,12 +97,20 @@ const T = {
 
   // config
   cfgExists:      { en: (p) => `${p} already exists. Overwrite?`, zh: (p) => `${p} 已存在，是否覆盖？` },
+
+  // start mode
+  startModePrompt: { en: 'Start Mode', zh: '启动方式' },
+  startModeOpts:   { en: ['Background service (recommended, auto-start on boot)', 'Foreground (manual start each time)'], zh: ['后台服务（推荐，开机自启）', '前台运行（每次手动启动）'] },
+  startModeVals:   ['daemon', 'start'],
+  startModeSkip:   { en: '  → Daemon not supported on this platform, using foreground mode', zh: '  → 当前平台不支持后台服务，使用前台模式' },
   cfgKept:        { en: '✔ Keeping existing config', zh: '✔ 保留现有配置' },
   cfgKeptNote:    { en: '  Settings from this session were not saved', zh: '  本次填写的设置未保存' },
   cfgSaved:       { en: '✔ Config saved', zh: '✔ 配置已保存' },
   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: {
@@ -153,7 +161,7 @@ const tf = (key, ...args) => {
 
 // ── Step header ───────────────────────────────────────────────────────────────
 
-const TOTAL_STEPS = 6;
+const TOTAL_STEPS = 7;
 function stepHeader(n) {
   const title = T.stepTitles[uiLang][n - 1] ?? T.stepTitles.en[n - 1];
   const stepLabel = tf('step', n, TOTAL_STEPS);
@@ -639,13 +647,25 @@ async function main() {
     }
   }
 
+  // ── Step 7: Start Mode ──────────────────────────────────────────────────
+  write('\n');
+  stepHeader(7);
+
+  let startMode = 'start';
+  const daemonPlatform = process.platform === 'darwin' || process.platform === 'linux';
+  if (daemonPlatform) {
+    startMode = await select('startModePrompt', 'startModeOpts', 'startModeVals');
+  } else {
+    write(c.dim(t('startModeSkip') + '\n'));
+  }
+
   const config = {
     mindRoot:    mindDir,
     port:        webPort,
     mcpPort:     mcpPort,
     authToken:   authToken,
     webPassword: webPassword || '',
-    startMode:   'start',
+    startMode:   startMode,
     ai: {
       provider:  isSkip ? existingAiProvider : (isAnthropic ? 'anthropic' : 'openai'),
       providers: existingProviders,
@@ -656,7 +676,16 @@ async function main() {
   writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n');
   console.log(`\n${c.green(t('cfgSaved'))}: ${c.dim(CONFIG_PATH)}`);
 
-  const installDaemon = process.argv.includes('--install-daemon');
+  // ── 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)