@geminilight/mindos 0.6.39 → 0.6.40

package/bin/cli.js

@@ -39,7 +39,7 @@
  */
 
 import { execSync, execFileSync, spawn as nodeSpawn } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, rmSync, cpSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, cpSync, unlinkSync, mkdirSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { homedir } from 'node:os';
 
@@ -371,21 +371,41 @@ const commands = {
       killByPort(Number(startupCfg.setupPort));
     }
 
-    // ── Auto-migrate user-rules.md to root user-skill-rules.md ─────────────
+    // ── Auto-migrate user preferences → .mindos/user-preferences.md ────────
     try {
       const mr = startupCfg.mindRoot;
       if (mr && existsSync(mr)) {
-        const isZh = startupCfg.disabledSkills?.includes('mindos');
-        const sName = isZh ? 'mindos-zh' : 'mindos';
-        const sDir = resolve(mr, '.agents', 'skills', sName);
-        const rootUserRules = resolve(mr, 'user-skill-rules.md');
-
-        // Migrate: .agents/skills/{name}/user-rules.md → {mindRoot}/user-skill-rules.md
-        if (!existsSync(rootUserRules)) {
-          const oldUserRules = resolve(sDir, 'user-rules.md');
-          if (existsSync(oldUserRules)) {
-            cpSync(oldUserRules, rootUserRules);
-            console.log(`  ${green('✓')} ${dim('Migrated user-rules.md → user-skill-rules.md')}`);
+        const mindosDir = resolve(mr, '.mindos');
+        const newPath = resolve(mindosDir, 'user-preferences.md');
+
+        if (!existsSync(newPath)) {
+          // Ensure .mindos/ directory exists
+          if (!existsSync(mindosDir)) mkdirSync(mindosDir, { recursive: true });
+
+          // Try migrate from previous locations (newest → oldest)
+          const prevPaths = [
+            resolve(mindosDir, 'user-rules.md'),                    // v0.6.x interim
+            resolve(mr, 'user-skill-rules.md'),                     // v0.5.x root
+          ];
+          let migrated = false;
+          for (const prev of prevPaths) {
+            if (existsSync(prev)) {
+              cpSync(prev, newPath);
+              unlinkSync(prev);
+              console.log(`  ${green('✓')} ${dim(`Migrated ${prev.split('/').pop()} → .mindos/user-preferences.md`)}`);
+              migrated = true;
+              break;
+            }
+          }
+          if (!migrated) {
+            // Try legacy location (.agents/skills/{name}/user-rules.md)
+            const isZh = startupCfg.disabledSkills?.includes('mindos');
+            const sName = isZh ? 'mindos-zh' : 'mindos';
+            const oldPath = resolve(mr, '.agents', 'skills', sName, 'user-rules.md');
+            if (existsSync(oldPath)) {
+              cpSync(oldPath, newPath);
+              console.log(`  ${green('✓')} ${dim('Migrated .agents/skills/ user-rules.md → .mindos/user-preferences.md')}`);
+            }
           }
         }
       }
@@ -567,19 +587,21 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
     }
 
     // Skill operating rules are now built into SKILL.md (shipped with the app).
-    // This command only initializes user-skill-rules.md for personalization.
-    const dest = resolve(mindRoot, 'user-skill-rules.md');
+    // This command only initializes .mindos/user-preferences.md for personalization.
+    const mindosDir = resolve(mindRoot, '.mindos');
+    const dest = resolve(mindosDir, 'user-preferences.md');
     if (existsSync(dest)) {
-      console.log(`  ${dim('skip')}  user-skill-rules.md (already exists)\n`);
+      console.log(`  ${dim('skip')}  .mindos/user-preferences.md (already exists)\n`);
     } else {
+      if (!existsSync(mindosDir)) mkdirSync(mindosDir, { recursive: true });
       const isZh = config.disabledSkills?.includes('mindos');
       const lang = isZh ? 'zh' : 'en';
       const src = resolve(ROOT, 'templates', 'skill-rules', lang, 'user-rules.md');
       if (existsSync(src)) {
         cpSync(src, dest);
-        console.log(`  ${green('✓')}  user-skill-rules.md created at ${dim(mindRoot)}\n`);
+        console.log(`  ${green('✓')}  .mindos/user-preferences.md created at ${dim(mindosDir)}\n`);
       } else {
-        console.log(`  ${dim('skip')}  Template not found, create user-skill-rules.md manually if needed.\n`);
+        console.log(`  ${dim('skip')}  Template not found, create .mindos/user-preferences.md manually if needed.\n`);
       }
     }
     console.log(`  ${dim('Note: Operating rules are now built into the app. No install needed.')}\n`);
@@ -841,7 +863,7 @@ ${dim('Shortcut: mindos start --daemon  →  install + start in one step')}
       const webPort = updateConfig.port ?? 3456;
       const mcpPort = updateConfig.mcpPort ?? 8781;
       console.log(dim('  (Waiting for Web UI to come back up — first run after update includes a rebuild...)'));
-      const ready = await waitForHttp(Number(webPort), { retries: 180, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
+      const ready = await waitForHttp(Number(webPort), { retries: 450, intervalMs: 2000, label: 'Web UI', logFile: LOG_PATH });
       if (ready) {
         const localIP = getLocalIP();
         console.log(`\n${'─'.repeat(53)}`);
@@ -1268,18 +1290,15 @@ ${bold('Examples:')}
     const mindRoot = process.env.MIND_ROOT;
 
     if (sub === 'init') {
-      // Parse --non-interactive --remote <url> --branch <branch> --token <token>
-      const args = cliArgs.slice(1);
-      const flagIdx = (flag) => args.indexOf(flag);
-      const flagVal = (flag) => { const i = flagIdx(flag); return i >= 0 && i + 1 < args.length ? args[i + 1] : ''; };
-      const nonInteractive = args.includes('--non-interactive');
+      // Flags are already parsed by parseArgs into cliFlags
+      const nonInteractive = cliFlags['non-interactive'] === true;
 
       if (nonInteractive) {
         await initSync(mindRoot, {
           nonInteractive: true,
-          remote: flagVal('--remote'),
-          token: flagVal('--token'),
-          branch: flagVal('--branch') || 'main',
+          remote: typeof cliFlags.remote === 'string' ? cliFlags.remote : '',
+          token: typeof cliFlags.token === 'string' ? cliFlags.token : '',
+          branch: (typeof cliFlags.branch === 'string' ? cliFlags.branch : '') || 'main',
         });
       } else {
         await initSync(mindRoot);

package/bin/commands/file.js

@@ -22,9 +22,12 @@ function getMindRoot() {
 }
 
 function resolvePath(root, filePath) {
-  // Accept both relative (to mind root) and absolute paths
-  if (filePath.startsWith('/')) return filePath;
-  return resolve(root, filePath);
+  const resolved = resolve(root, filePath);
+  if (resolved !== root && !resolved.startsWith(root + '/')) {
+    console.error(red(`Access denied: path outside knowledge base`));
+    process.exit(EXIT.ERROR);
+  }
+  return resolved;
 }
 
 export const meta = {
@@ -128,7 +131,7 @@ function walkFiles(dir, root, opts = {}) {
 
 function fileList(root, _args, flags) {
   const files = walkFiles(root, root, {
-    recursive: flags.recursive || flags.r || true,
+    recursive: flags.recursive ?? flags.r ?? true,
     space: flags.space || null,
   });
 

package/bin/commands/space.js

@@ -106,6 +106,10 @@ function countFiles(dir) {
 
 function resolvePath(root, relPath) {
   const full = relPath ? resolve(root, relPath) : root;
+  if (full !== root && !full.startsWith(root + '/')) {
+    console.error(red(`Access denied: path outside knowledge base`));
+    process.exit(EXIT.ERROR);
+  }
   if (!existsSync(full)) {
     console.error(red(`Not found: ${relPath || '(root)'}`));
     process.exit(EXIT.NOT_FOUND);

package/bin/lib/mcp-agents.js

@@ -32,7 +32,7 @@ export const MCP_AGENTS = {
     global: '~/.cursor/mcp.json',
     key: 'mcpServers',
     preferredTransport: 'stdio',
-    presenceDirs: ['~/.cursor/'],
+    presenceDirs: ['~/.cursor/extensions/'],
   },
   'windsurf': {
     name: 'Windsurf',
@@ -180,6 +180,30 @@ export const MCP_AGENTS = {
       '~/.config/Code/User/globalStorage/rooveterinaryinc.roo-cline/',
     ],
   },
+  'github-copilot': {
+    name: 'GitHub Copilot',
+    project: '.vscode/mcp.json',
+    global: process.platform === 'darwin'
+      ? '~/Library/Application Support/Code/User/mcp.json'
+      : '~/.config/Code/User/mcp.json',
+    key: 'servers',
+    preferredTransport: 'stdio',
+    presenceDirs: [
+      '~/Library/Application Support/Code/',
+      '~/.config/Code/',
+    ],
+    presenceCli: 'code',
+  },
+  'codex': {
+    name: 'Codex',
+    project: null,
+    global: '~/.codex/config.toml',
+    key: 'mcp_servers',
+    format: 'toml',
+    preferredTransport: 'stdio',
+    presenceCli: 'codex',
+    presenceDirs: ['~/.codex/'],
+  },
 };
 
 /**
@@ -204,7 +228,7 @@ export const SKILL_AGENT_REGISTRY = {
   'qoder': { mode: 'additional', skillAgentName: 'qoder' },
   'trae-cn': { mode: 'additional', skillAgentName: 'trae-cn' },
   'roo': { mode: 'additional', skillAgentName: 'roo' },
-  'vscode': { mode: 'universal' },
+  'github-copilot': { mode: 'universal' },
   'codex': { mode: 'universal' },
 };
 

package/bin/lib/mcp-install.js

@@ -309,8 +309,8 @@ export async function mcpInstall() {
       continue;
     }
 
-    // read + merge
-    const absPath = expandHome(configPath);
+    // read + merge — resolve to absolute path for cross-platform safety
+    const absPath = resolve(expandHome(configPath));
     let config = {};
     if (existsSync(absPath)) {
       try { config = parseJsonc(readFileSync(absPath, 'utf-8')); } catch {
@@ -331,5 +331,13 @@ export async function mcpInstall() {
     console.log(`${green('✔')} ${existed ? 'Updated' : 'Installed'} MindOS MCP for ${bold(agent.name)} ${dim(`→ ${absPath}`)}`);
   }
 
-  console.log(`\n${green('Done!')} ${agentKeys.length} agent(s) configured.\n`);
+  console.log(`\n${green('Done!')} ${agentKeys.length} agent(s) configured.`);
+
+  // Agents that require manual restart to pick up config changes
+  const needsRestart = new Set(['cursor', 'windsurf', 'trae', 'cline', 'roo-code']);
+  const restartAgents = agentKeys.filter(k => needsRestart.has(k)).map(k => MCP_AGENTS[k].name);
+  if (restartAgents.length > 0) {
+    console.log(`\n${yellow('Tip:')} ${restartAgents.join(', ')} must be restarted to load the new MCP config.`);
+  }
+  console.log();
 }

package/bin/lib/sync.js

@@ -66,6 +66,54 @@ function gitExec(args, cwd) {
   return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
 }
 
+/** Check if URL is SSH format (git@host:path) */
+function isSSHUrl(url) {
+  return /^git@[\w.-]+:.+/.test(url);
+}
+
+/** Get SSH environment for git commands to auto-accept new hosts */
+function getSshEnv() {
+  // StrictHostKeyChecking=accept-new: auto-add unknown hosts to known_hosts
+  // BatchMode=yes: no interactive prompts (fail fast if key not available)
+  const sshCmd = 'ssh -o StrictHostKeyChecking=accept-new -o BatchMode=yes';
+  return { GIT_SSH_COMMAND: sshCmd };
+}
+
+/** Validate SSH setup before attempting to use SSH URL */
+function validateSSHSetup(url, mindRoot, nonInteractive) {
+  if (!isSSHUrl(url)) return { isSSH: false };
+
+  const sshDir = resolve(homedir(), '.ssh');
+  const id_rsa = resolve(sshDir, 'id_rsa');
+  const id_ed25519 = resolve(sshDir, 'id_ed25519');
+  const hasKey = existsSync(id_rsa) || existsSync(id_ed25519);
+  const hasAgent = !!process.env.SSH_AUTH_SOCK;
+
+  if (!hasKey && !hasAgent) {
+    const hint = isSSHUrl(url)
+      ? `SSH key not found at ${sshDir}/id_rsa or id_ed25519. Create one with:\n` +
+        `  ssh-keygen -t ed25519 -f ${id_rsa}\n` +
+        `Then verify with: ssh -T git@github.com`
+      : '';
+    return {
+      isSSH: true,
+      isValid: false,
+      error: `No SSH credentials found. ${hint}`,
+    };
+  }
+
+  return { isSSH: true, isValid: true };
+}
+
+/** Execute git command with SSH support (auto-add to known_hosts on first connection) */
+function gitExecSSH(args, cwd, isSSH = false, timeoutMs = 15000) {
+  const opts = { cwd, encoding: 'utf-8', stdio: 'pipe', timeout: timeoutMs };
+  if (isSSH) {
+    opts.env = { ...process.env, ...getSshEnv() };
+  }
+  return execFileSync('git', args, opts).trim();
+}
+
 function getRemoteUrl(cwd) {
   try {
     return gitExec(['remote', 'get-url', 'origin'], cwd);
@@ -92,23 +140,37 @@ function getUnpushedCount(cwd) {
 
 // ── Core sync functions ─────────────────────────────────────────────────────
 
-function autoCommitAndPush(mindRoot) {
+function autoCommitAndPush(mindRoot, isSshUrl = false) {
+  const sshEnv = isSshUrl ? getSshEnv() : {};
+  const pushEnv = { ...process.env, ...sshEnv };
+
+  // Stage and commit any pending changes
   try {
     execFileSync('git', ['add', '-A'], { cwd: mindRoot, stdio: 'pipe' });
     const status = gitExec(['status', '--porcelain'], mindRoot);
-    if (!status) return;
-    const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
-    execFileSync('git', ['commit', '-m', `auto-sync: ${timestamp}`], { cwd: mindRoot, stdio: 'pipe' });
-    execFileSync('git', ['push', '-u', 'origin', 'HEAD'], { cwd: mindRoot, stdio: 'pipe' });
+    if (status) {
+      const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
+      execFileSync('git', ['commit', '-m', `auto-sync: ${timestamp}`], { cwd: mindRoot, stdio: 'pipe' });
+    }
+  } catch (err) {
+    saveSyncState({ ...loadSyncState(), lastError: `Commit failed: ${err.message}`, lastErrorTime: new Date().toISOString() });
+    return;
+  }
+
+  // Always try to push (even if no new commit — there may be unpushed commits from previous runs)
+  try {
+    execFileSync('git', ['push', '-u', 'origin', 'HEAD'], { cwd: mindRoot, stdio: 'pipe', env: pushEnv });
     saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
   } catch (err) {
-    saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
+    saveSyncState({ ...loadSyncState(), lastError: `Push failed: ${err.message}`, lastErrorTime: new Date().toISOString() });
+    throw err; // Let caller know push failed
   }
 }
 
-function autoPull(mindRoot) {
+function autoPull(mindRoot, isSshUrl = false) {
+  const sshEnv = isSshUrl ? getSshEnv() : {};
   try {
-    execFileSync('git', ['pull', '--rebase', '--autostash'], { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['pull', '--rebase', '--autostash'], { cwd: mindRoot, stdio: 'pipe', env: { ...process.env, ...sshEnv } });
     saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
   } catch {
     // rebase conflict → abort → merge
@@ -118,9 +180,10 @@ function autoPull(mindRoot) {
       saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
     } catch {
       // merge conflict → keep both versions
+      let conflicts = [];
+      let conflictWarnings = [];
       try {
-        const conflicts = gitExec(['diff', '--name-only', '--diff-filter=U'], mindRoot).split('\n').filter(Boolean);
-        const conflictWarnings = [];
+        conflicts = gitExec(['diff', '--name-only', '--diff-filter=U'], mindRoot).split('\n').filter(Boolean);
         for (const file of conflicts) {
           try {
             const theirs = execFileSync('git', ['show', `:3:${file}`], { cwd: mindRoot, encoding: 'utf-8' });
@@ -131,27 +194,36 @@ function autoPull(mindRoot) {
           try { execFileSync('git', ['checkout', '--ours', file], { cwd: mindRoot, stdio: 'pipe' }); } catch {}
         }
         execFileSync('git', ['add', '-A'], { cwd: mindRoot, stdio: 'pipe' });
-        execFileSync('git', ['commit', '-m', 'auto-sync: resolved conflicts (kept both versions)'], { cwd: mindRoot, stdio: 'pipe' });
+        // --no-edit avoids editor prompt for merge commit; --allow-empty handles edge case where ours == theirs
+        try {
+          execFileSync('git', ['-c', 'core.editor=true', 'commit', '--no-edit'], { cwd: mindRoot, stdio: 'pipe' });
+        } catch {
+          // If merge commit fails (e.g. nothing to commit), try explicit message
+          try {
+            execFileSync('git', ['commit', '-m', 'auto-sync: resolved conflicts (kept local versions)', '--allow-empty'], { cwd: mindRoot, stdio: 'pipe' });
+          } catch {}
+        }
+      } catch (err) {
+        // Even if commit fails, record the error — conflicts are still saved below
+        saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
+      }
+      // Always save conflicts (even if commit failed) so UI can show resolution buttons
+      if (conflicts.length > 0) {
         saveSyncState({
           ...loadSyncState(),
           lastPull: new Date().toISOString(),
           conflicts: conflicts.map(f => ({ file: f, time: new Date().toISOString(), noBackup: conflictWarnings.includes(f) })),
         });
-      } catch (err) {
-        saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
       }
     }
   }
 
   // Retry any pending pushes (handles previous push failures)
   try {
-    const unpushed = gitExec(['rev-list', '--count', '@{u}..HEAD'], mindRoot);
-    if (parseInt(unpushed) > 0) {
-      execFileSync('git', ['push'], { cwd: mindRoot, stdio: 'pipe' });
-      saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
-    }
+    execFileSync('git', ['push', '-u', 'origin', 'HEAD'], { cwd: mindRoot, stdio: 'pipe', env: { ...process.env, ...sshEnv } });
+    saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
   } catch {
-    // No upstream tracking or push failed — ignore silently, autoCommitAndPush handles primary pushes
+    // Push failed — will be retried next cycle or by manualSync
   }
 }
 
@@ -205,7 +277,15 @@ export async function initSync(mindRoot, opts = {}) {
     rl.close();
   }
 
-  // 1. Ensure git repo
+  // Pre-flight SSH validation (before git init)
+  const sshValidation = validateSSHSetup(remoteUrl, mindRoot, nonInteractive);
+  if (sshValidation.isSSH && !sshValidation.isValid) {
+    const err = sshValidation.error;
+    if (nonInteractive) throw new Error(err);
+    console.error(red(`✘ ${err}`));
+    process.exit(1);
+  }
+  const isSshUrl = sshValidation.isSSH;
   if (!isGitRepo(mindRoot)) {
     if (!nonInteractive) console.log(dim('Initializing git repository...'));
     execFileSync('git', ['init'], { cwd: mindRoot, stdio: 'pipe' });
@@ -213,7 +293,11 @@ export async function initSync(mindRoot, opts = {}) {
   }
 
   // 1b. Ensure .gitignore exists
+  // 1b. Ensure .gitignore has system file exclusions
   const gitignorePath = resolve(mindRoot, '.gitignore');
+  const SYSTEM_IGNORES = [
+    'INSTRUCTION.md',
+  ];
   if (!existsSync(gitignorePath)) {
     writeFileSync(gitignorePath, [
       '# MindOS auto-generated',
@@ -226,7 +310,23 @@ export async function initSync(mindRoot, opts = {}) {
       'node_modules/',
       '.obsidian/',
       '',
+      '# MindOS system files (regenerated on update, not user content)',
+      ...SYSTEM_IGNORES,
+      '',
     ].join('\n'), 'utf-8');
+  } else {
+    // Existing .gitignore — append missing system file entries
+    const existing = readFileSync(gitignorePath, 'utf-8');
+    const missing = SYSTEM_IGNORES.filter(f => !existing.includes(f));
+    if (missing.length > 0) {
+      const append = '\n# MindOS system files (auto-added)\n' + missing.join('\n') + '\n';
+      writeFileSync(gitignorePath, existing.trimEnd() + '\n' + append, 'utf-8');
+    }
+  }
+
+  // Remove system files from git tracking if already committed
+  for (const file of SYSTEM_IGNORES) {
+    try { execFileSync('git', ['rm', '--cached', '--ignore-unmatch', file], { cwd: mindRoot, stdio: 'pipe' }); } catch {}
   }
 
   // Handle token for HTTPS
@@ -283,12 +383,11 @@ export async function initSync(mindRoot, opts = {}) {
     execFileSync('git', ['remote', 'set-url', 'origin', remoteUrl], { cwd: mindRoot, stdio: 'pipe' });
   }
 
-  // 5. Test connection
+  // 5. Test connection (also captures refs to avoid a second SSH round-trip)
   if (!nonInteractive) console.log(dim('Testing connection...'));
+  let remoteRefs = '';
   try {
-    // `git ls-remote --exit-code origin` returns non-zero for an empty remote,
-    // which breaks first-time setup against a freshly created repository.
-    execFileSync('git', ['ls-remote', 'origin'], { cwd: mindRoot, stdio: 'pipe', timeout: 15000 });
+    remoteRefs = gitExecSSH(['ls-remote', 'origin'], mindRoot, isSshUrl, 15000);
     if (!nonInteractive) console.log(green('✔ Connection successful'));
   } catch (lsErr) {
     const detail = lsErr.stderr ? lsErr.stderr.toString().trim() : '';
@@ -311,22 +410,24 @@ export async function initSync(mindRoot, opts = {}) {
   if (!nonInteractive) console.log(green('✔ Sync configured'));
 
   // 7. First sync: pull if remote has content, push otherwise
+  //    Reuse remoteRefs from step 5 to avoid redundant SSH connection (~3-4s saved)
+  const hasRemoteContent = remoteRefs.includes('refs/heads/');
   try {
-    const refs = gitExec(['ls-remote', '--heads', 'origin'], mindRoot);
-    if (refs) {
+    if (hasRemoteContent) {
       if (!nonInteractive) console.log(dim('Pulling from remote...'));
       try {
-        execFileSync('git', ['pull', 'origin', syncConfig.branch, '--allow-unrelated-histories'], { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit' });
+        const pullEnv = isSshUrl ? { ...process.env, ...getSshEnv() } : process.env;
+        execFileSync('git', ['pull', 'origin', syncConfig.branch, '--allow-unrelated-histories'], { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit', env: pullEnv });
       } catch {
         if (!nonInteractive) console.log(yellow('Pull completed with warnings. Check for conflicts.'));
       }
     } else {
       if (!nonInteractive) console.log(dim('Pushing to remote...'));
-      autoCommitAndPush(mindRoot);
+      autoCommitAndPush(mindRoot, isSshUrl);
     }
   } catch {
     if (!nonInteractive) console.log(dim('Performing initial push...'));
-    autoCommitAndPush(mindRoot);
+    autoCommitAndPush(mindRoot, isSshUrl);
   }
   if (!nonInteractive) console.log(green('✔ Initial sync complete\n'));
 }
@@ -340,6 +441,9 @@ export async function startSyncDaemon(mindRoot) {
   if (!config.enabled) return null;
   if (!mindRoot || !isGitRepo(mindRoot)) return null;
 
+  const remoteUrl = getRemoteUrl(mindRoot) || '';
+  const isSshUrl = isSSHUrl(remoteUrl);
+
   const chokidar = await import('chokidar');
 
   // File watcher → debounced auto-commit + push
@@ -351,14 +455,14 @@ export async function startSyncDaemon(mindRoot) {
   });
   watcher.on('all', () => {
     clearTimeout(commitTimer);
-    commitTimer = setTimeout(() => autoCommitAndPush(mindRoot), (config.autoCommitInterval || 30) * 1000);
+    commitTimer = setTimeout(() => autoCommitAndPush(mindRoot, isSshUrl), (config.autoCommitInterval || 30) * 1000);
   });
 
   // Periodic pull
-  const pullInterval = setInterval(() => autoPull(mindRoot), (config.autoPullInterval || 300) * 1000);
+  const pullInterval = setInterval(() => autoPull(mindRoot, isSshUrl), (config.autoPullInterval || 300) * 1000);
 
   // Pull on startup
-  autoPull(mindRoot);
+  autoPull(mindRoot, isSshUrl);
 
   // Graceful shutdown: flush pending changes before exit
   let shutdownInProgress = false;
@@ -435,8 +539,10 @@ export function manualSync(mindRoot) {
   if (!mindRoot || !isGitRepo(mindRoot)) {
     throw new Error('Not a git repository. Run `mindos sync init` first.');
   }
-  autoPull(mindRoot);
-  autoCommitAndPush(mindRoot);
+  const remoteUrl = getRemoteUrl(mindRoot) || '';
+  const isSshUrl = isSSHUrl(remoteUrl);
+  autoPull(mindRoot, isSshUrl);
+  autoCommitAndPush(mindRoot, isSshUrl); // throws on push failure → API returns error
 }
 
 /**

package/mcp/README.md

@@ -37,7 +37,7 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `MINDOS_URL` | `http://localhost:3456` | App server base URL |
 | `AUTH_TOKEN` | — | Optional: bearer token (must match App's `AUTH_TOKEN`) |
 | `MCP_TRANSPORT` | `http` | Transport mode: `http` or `stdio` |
-| `MCP_HOST` | `127.0.0.1` | HTTP bind address (`0.0.0.0` for remote access) |
+| `MCP_HOST` | `0.0.0.0` | HTTP bind address (`127.0.0.1` for local only) |
 | `MCP_PORT` | `8781` | HTTP listen port (configurable via `mindos onboard`) |
 | `MCP_ENDPOINT` | `/mcp` | HTTP endpoint path |
 
@@ -52,7 +52,7 @@ MCP_TRANSPORT=stdio mindos mcp   # stdio mode
 | `mindos_create_file` | `POST /api/file` op=create_file | Create a new .md or .csv file |
 | `mindos_create_space` | `POST /api/file` op=create_space | Create a Mind Space (README + INSTRUCTION scaffold) |
 | `mindos_rename_space` | `POST /api/file` op=rename_space | Rename a Space directory (folder only) |
-| `mindos_delete_file` | `POST /api/file` op=delete_file | Delete a file |
+| `mindos_delete_file` | `POST /api/file` op=delete_file | Delete a file (moved to trash, recoverable for 30 days) |
 | `mindos_rename_file` | `POST /api/file` op=rename_file | Rename a file (same directory) |
 | `mindos_move_file` | `POST /api/file` op=move_file | Move a file to a new path |
 | `mindos_search_notes` | `GET /api/search?q=...` | Full-text search across all files |