@geminilight/mindos 0.1.9 → 0.2.0

package/bin/cli.js

@@ -15,7 +15,13 @@
  *   mindos mcp                      — start MCP server only
  *   mindos stop                     — stop running MindOS processes
  *   mindos restart                  — stop then start
+ *   mindos open                     — open Web UI in the default browser
  *   mindos token                    — show current auth token and MCP config snippet
+ *   mindos sync                     — show sync status
+ *   mindos sync init                — configure remote git repo for sync
+ *   mindos sync now                 — manual trigger sync
+ *   mindos sync conflicts           — list conflict files
+ *   mindos sync on|off              — enable/disable auto-sync
  *   mindos gateway install          — install background service (systemd/launchd)
  *   mindos gateway uninstall        — remove background service
  *   mindos gateway start            — start the background service
@@ -38,20 +44,21 @@ import { homedir } from 'node:os';
 import { ROOT, CONFIG_PATH, BUILD_STAMP, LOG_PATH } from './lib/constants.js';
 import { bold, dim, cyan, green, red, yellow } from './lib/colors.js';
 import { run } from './lib/utils.js';
-import { loadConfig, getStartMode } from './lib/config.js';
+import { loadConfig, getStartMode, isDaemonMode } from './lib/config.js';
 import { needsBuild, writeBuildStamp, clearBuildLock, cleanNextDir, ensureAppDeps } from './lib/build.js';
 import { isPortInUse, assertPortFree } from './lib/port.js';
 import { savePids, clearPids } from './lib/pid.js';
 import { stopMindos } from './lib/stop.js';
 import { getPlatform, ensureMindosDir, waitForHttp, runGatewayCommand } from './lib/gateway.js';
-import { printStartupInfo } from './lib/startup.js';
+import { printStartupInfo, getLocalIP } from './lib/startup.js';
 import { spawnMcp } from './lib/mcp-spawn.js';
 import { mcpInstall } from './lib/mcp-install.js';
+import { initSync, startSyncDaemon, stopSyncDaemon, getSyncStatus, manualSync, listConflicts, setSyncEnabled } from './lib/sync.js';
 
 // ── Commands ──────────────────────────────────────────────────────────────────
 
 const cmd       = process.argv[2];
-const isDaemon  = process.argv.includes('--daemon');
+const isDaemon  = process.argv.includes('--daemon') || (!cmd && isDaemonMode());
 const isVerbose = process.argv.includes('--verbose');
 const extra     = process.argv.slice(3).filter(a => a !== '--daemon' && a !== '--verbose').join(' ');
 
@@ -64,22 +71,117 @@ const commands = {
   init:  () => run(`node ${resolve(ROOT, 'scripts/setup.js')}`),
   setup: () => run(`node ${resolve(ROOT, 'scripts/setup.js')}`),
 
+  // ── open ───────────────────────────────────────────────────────────────────
+  open: () => {
+    loadConfig();
+    const webPort = process.env.MINDOS_WEB_PORT || '3000';
+    const url = `http://localhost:${webPort}`;
+    let cmd;
+    if (process.platform === 'darwin') {
+      cmd = 'open';
+    } else if (process.platform === 'linux') {
+      // WSL detection
+      try {
+        const uname = execSync('uname -r', { encoding: 'utf-8' });
+        cmd = uname.toLowerCase().includes('microsoft') ? 'wslview' : 'xdg-open';
+      } catch {
+        cmd = 'xdg-open';
+      }
+    } else {
+      cmd = 'start';
+    }
+    try {
+      execSync(`${cmd} ${url}`, { stdio: 'ignore' });
+      console.log(`${green('✔')} Opening ${cyan(url)}`);
+    } catch {
+      console.log(dim(`Could not open browser automatically. Visit: ${cyan(url)}`));
+    }
+  },
+
   // ── token ──────────────────────────────────────────────────────────────────
   token: () => {
     if (!existsSync(CONFIG_PATH)) {
       console.error(red('No config found. Run `mindos onboard` first.'));
       process.exit(1);
     }
-    let token = '';
-    try { token = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).authToken || ''; } catch {}
+    let config = {};
+    try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
+    const token = config.authToken || '';
     if (!token) {
       console.log(dim('No auth token set. Run `mindos onboard` to configure one.'));
       process.exit(0);
     }
+    const mcpPort = config.mcpPort || 8787;
+    const localIP = getLocalIP();
+
+    const localUrl = `http://localhost:${mcpPort}/mcp`;
+    const sep = '━'.repeat(40);
+
     console.log(`\n${bold('🔑 Auth token:')} ${cyan(token)}\n`);
-    console.log(dim('Add to your Agent MCP config:'));
-    console.log(`  "headers": { "Authorization": "Bearer ${cyan(token)}" }\n`);
-    console.log(dim('Run `mindos onboard` to regenerate.\n'));
+
+    // Claude Code
+    console.log(`${sep}`);
+    console.log(`${bold('Claude Code')}`);
+    console.log(`${sep}`);
+    console.log(dim('一键安装:') + ` mindos mcp install claude-code -g -y`);
+    console.log(dim('\n手动配置 (~/.claude.json):'));
+    console.log(JSON.stringify({
+      mcpServers: {
+        mindos: {
+          url: localUrl,
+          headers: { Authorization: `Bearer ${token}` },
+        },
+      },
+    }, null, 2));
+
+    // CodeBuddy (Claude Code Internal)
+    console.log(`\n${sep}`);
+    console.log(`${bold('CodeBuddy (Claude Code Internal)')}`);
+    console.log(`${sep}`);
+    console.log(dim('一键安装:') + ` mindos mcp install codebuddy -g -y`);
+    console.log(dim('\n手动配置 (~/.claude-internal/.claude.json):'));
+    console.log(JSON.stringify({
+      mcpServers: {
+        mindos: {
+          url: localUrl,
+          headers: { Authorization: `Bearer ${token}` },
+        },
+      },
+    }, null, 2));
+
+    // Cursor
+    console.log(`\n${sep}`);
+    console.log(`${bold('Cursor')}`);
+    console.log(`${sep}`);
+    console.log(dim('一键安装:') + ` mindos mcp install cursor -g -y`);
+    console.log(dim('\n手动配置 (~/.cursor/mcp.json):'));
+    console.log(JSON.stringify({
+      mcpServers: {
+        mindos: {
+          url: localUrl,
+          headers: { Authorization: `Bearer ${token}` },
+        },
+      },
+    }, null, 2));
+
+    // Remote
+    if (localIP) {
+      const remoteUrl = `http://${localIP}:${mcpPort}/mcp`;
+      console.log(`\n${sep}`);
+      console.log(`${bold('Remote (其他设备)')}`);
+      console.log(`${sep}`);
+      console.log(`URL: ${cyan(remoteUrl)}`);
+      console.log(JSON.stringify({
+        mcpServers: {
+          mindos: {
+            url: remoteUrl,
+            headers: { Authorization: `Bearer ${token}` },
+          },
+        },
+      }, null, 2));
+    }
+
+    console.log(dim('\nRun `mindos onboard` to regenerate.\n'));
   },
 
   // ── dev ────────────────────────────────────────────────────────────────────
@@ -92,7 +194,12 @@ const commands = {
     ensureAppDeps();
     const mcp = spawnMcp(isVerbose);
     savePids(process.pid, mcp.pid);
-    process.on('exit', clearPids);
+    process.on('exit', () => { stopSyncDaemon(); clearPids(); });
+    // Start sync daemon if enabled
+    const devMindRoot = process.env.MIND_ROOT;
+    if (devMindRoot) {
+      startSyncDaemon(devMindRoot).catch(() => {});
+    }
     printStartupInfo(webPort, mcpPort);
     run(`npx next dev -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
   },
@@ -119,6 +226,14 @@ const commands = {
           process.exit(1);
         }
         printStartupInfo(webPort, mcpPort);
+        // System notification
+        try {
+          if (process.platform === 'darwin') {
+            execSync(`osascript -e 'display notification "http://localhost:${webPort}" with title "MindOS 已就绪"'`, { stdio: 'ignore' });
+          } else if (process.platform === 'linux') {
+            execSync(`notify-send "MindOS 已就绪" "http://localhost:${webPort}"`, { stdio: 'ignore' });
+          }
+        } catch { /* notification is best-effort */ }
         console.log(`${green('✔ MindOS is running as a background service')}`);
         console.log(dim('  View logs:    mindos logs'));
         console.log(dim('  Stop:         mindos gateway stop'));
@@ -140,7 +255,12 @@ const commands = {
     }
     const mcp = spawnMcp(isVerbose);
     savePids(process.pid, mcp.pid);
-    process.on('exit', clearPids);
+    process.on('exit', () => { stopSyncDaemon(); clearPids(); });
+    // Start sync daemon if enabled
+    const mindRoot = process.env.MIND_ROOT;
+    if (mindRoot) {
+      startSyncDaemon(mindRoot).catch(() => {});
+    }
     printStartupInfo(webPort, mcpPort);
     run(`npx next start -p ${webPort} ${extra}`, resolve(ROOT, 'app'));
   },
@@ -521,6 +641,67 @@ ${bold('Examples:')}
   ${dim('mindos config set ai.provider openai')}
 `);
   },
+
+  // ── sync ──────────────────────────────────────────────────────────────────
+  sync: async () => {
+    const sub = process.argv[3];
+    loadConfig();
+    const mindRoot = process.env.MIND_ROOT;
+
+    if (sub === 'init') {
+      await initSync(mindRoot);
+      return;
+    }
+
+    if (sub === 'now') {
+      manualSync(mindRoot);
+      return;
+    }
+
+    if (sub === 'conflicts') {
+      listConflicts(mindRoot);
+      return;
+    }
+
+    if (sub === 'on') {
+      setSyncEnabled(true);
+      return;
+    }
+
+    if (sub === 'off') {
+      setSyncEnabled(false);
+      stopSyncDaemon();
+      return;
+    }
+
+    // default: sync status
+    const status = getSyncStatus(mindRoot);
+    if (!status.enabled) {
+      console.log(`\n${bold('🔄 Sync Status')}`);
+      console.log(dim('  Not configured. Run `mindos sync init` to set up.\n'));
+      return;
+    }
+    const ago = status.lastSync
+      ? (() => {
+          const diff = Date.now() - new Date(status.lastSync).getTime();
+          if (diff < 60000) return 'just now';
+          if (diff < 3600000) return `${Math.floor(diff / 60000)} minutes ago`;
+          return `${Math.floor(diff / 3600000)} hours ago`;
+        })()
+      : 'never';
+
+    console.log(`\n${bold('🔄 Sync Status')}`);
+    console.log(`  ${dim('Provider:')}    ${cyan(`${status.provider} (${status.remote})`)}`);
+    console.log(`  ${dim('Branch:')}      ${cyan(status.branch)}`);
+    console.log(`  ${dim('Last sync:')}   ${ago}`);
+    console.log(`  ${dim('Unpushed:')}    ${status.unpushed} commits`);
+    console.log(`  ${dim('Conflicts:')}   ${status.conflicts.length ? yellow(`${status.conflicts.length} file(s)`) : green('none')}`);
+    console.log(`  ${dim('Auto-sync:')}   ${green('● enabled')} ${dim(`(commit: ${status.autoCommitInterval}s, pull: ${status.autoPullInterval / 60}min)`)}`);
+    if (status.lastError) {
+      console.log(`  ${dim('Last error:')}  ${red(status.lastError)}`);
+    }
+    console.log();
+  },
 };
 
 // ── Entry ─────────────────────────────────────────────────────────────────────
@@ -545,7 +726,9 @@ ${row('mindos restart',                    'Stop then start again')}
 ${row('mindos build',                      'Build the app for production')}
 ${row('mindos mcp',                        'Start MCP server only')}
 ${row('mindos mcp install [agent]',        'Install MindOS MCP config into Agent (claude-code/cursor/windsurf/…) [-g]')}
+${row('mindos open',                       'Open Web UI in the default browser')}
 ${row('mindos token',                      'Show current auth token and MCP config snippet')}
+${row('mindos sync',                       'Show sync status (init/now/conflicts/on/off)')}
 ${row('mindos gateway <subcommand>',       'Manage background service (install/uninstall/start/stop/status/logs)')}
 ${row('mindos doctor',                     'Health check (config, ports, build, daemon)')}
 ${row('mindos update',                     'Update MindOS to the latest version')}

package/bin/lib/config.js

@@ -40,8 +40,19 @@ export function loadConfig() {
 
 export function getStartMode() {
   try {
-    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).startMode || 'start';
+    const mode = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).startMode || 'start';
+    // 'daemon' is stored in config when user chose background service;
+    // CLI maps it to the 'start' command with --daemon flag
+    return mode === 'daemon' ? 'start' : mode;
   } catch {
     return 'start';
   }
 }
+
+export function isDaemonMode() {
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')).startMode === 'daemon';
+  } catch {
+    return false;
+  }
+}

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "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"
   }
 }