@geminilight/mindos 0.6.39 → 0.6.41

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 |