total-recall-brain 3.1.2 → 3.2.2

package/src/cli/backup.mjs

@@ -36,7 +36,7 @@ function commandExists(cmd) {
 function parseArgs(args) {
   // Parse layer flag first
   const { layer, remainingArgs } = parseLayerFlag(args);
-  const opts = { output: null, encrypt: true, pushGit: null, obsidian: null, help: false, layer };
+  const opts = { output: null, encrypt: true, pushGit: null, obsidian: null, install: false, help: false, layer };
   for (let i = 0; i < remainingArgs.length; i++) {
     switch (remainingArgs[i]) {
       case '--output':
@@ -52,6 +52,9 @@ function parseArgs(args) {
       case '--obsidian':
         opts.obsidian = remainingArgs[++i];
         break;
+      case '--install':
+        opts.install = true;
+        break;
       case '--help':
       case '-h':
         opts.help = true;
@@ -246,6 +249,168 @@ function obsidianBackup(vaultPath, layer = 'auto') {
   console.error(`  ✅ Brain synced to Obsidian (${stamp})`);
 }
 
+/**
+ * --install: Full automatic backup setup.
+ *   1. Creates a private GitHub repo via `gh` CLI
+ *   2. Writes .gitignore for derived/cache files
+ *   3. Inits git, does first push
+ *   4. Installs a daily launchd plist (macOS) or cron job (Linux)
+ */
+async function installBackup(layer = 'auto') {
+  const SKILL_DIR = getSkillDir(layer);
+  if (!fs.existsSync(SKILL_DIR)) {
+    console.error(`  ❌ Meta-skill not found: ${SKILL_DIR}`);
+    console.error('  Run: npx total-recall init');
+    process.exit(1);
+  }
+
+  if (!commandExists('gh')) {
+    console.error('  ❌ GitHub CLI (gh) not found. Install: brew install gh');
+    process.exit(1);
+  }
+
+  // Determine a repo name from the project directory
+  const projectDir = process.cwd();
+  const projectName = path.basename(projectDir).replace(/[^a-zA-Z0-9-]/g, '-').toLowerCase();
+  const isGlobal = SKILL_DIR.startsWith(os.homedir() + '/.agent');
+  const repoName = isGlobal ? 'global-brain-backup' : `${projectName}-brain-backup`;
+
+  // Get GitHub username
+  const whoami = spawnSync('gh', ['api', 'user', '--jq', '.login'], { stdio: 'pipe' });
+  if (whoami.status !== 0) {
+    console.error('  ❌ Not authenticated with GitHub CLI. Run: gh auth login');
+    process.exit(1);
+  }
+  const ghUser = whoami.stdout.toString().trim();
+  const remoteUrl = `git@github.com:${ghUser}/${repoName}.git`;
+
+  console.error(`\n  🧠 Installing automatic backup for brain at:`);
+  console.error(`     ${SKILL_DIR}`);
+  console.error(`     → ${ghUser}/${repoName} (private)\n`);
+
+  // 1. Create GitHub repo (skip if exists)
+  const checkRepo = spawnSync('gh', ['repo', 'view', `${ghUser}/${repoName}`, '--json', 'name'], { stdio: 'pipe' });
+  if (checkRepo.status !== 0) {
+    console.error('  📦 Creating private GitHub repo...');
+    const create = spawnSync('gh', ['repo', 'create', `${ghUser}/${repoName}`, '--private', '--description', `Auto-backup: ${isGlobal ? 'Global brain (identity layer)' : projectName + ' project brain'}`], { stdio: 'pipe' });
+    if (create.status !== 0) {
+      console.error(`  ❌ Failed to create repo: ${create.stderr?.toString()}`);
+      process.exit(1);
+    }
+    console.error(`  ✅ Created ${ghUser}/${repoName}`);
+  } else {
+    console.error(`  ✅ Repo ${ghUser}/${repoName} already exists`);
+  }
+
+  // 2. Write .gitignore for derived/cache files
+  const gitignorePath = path.join(SKILL_DIR, '.gitignore');
+  const gitignoreEntries = ['memory-derived/', 'sessions/', '*.backup', 'logs/', 'node_modules/'];
+  let existingIgnore = '';
+  if (fs.existsSync(gitignorePath)) {
+    existingIgnore = fs.readFileSync(gitignorePath, 'utf8');
+  }
+  const missing = gitignoreEntries.filter(e => !existingIgnore.includes(e));
+  if (missing.length > 0) {
+    fs.appendFileSync(gitignorePath, '\n# Auto-added by total-recall backup --install\n' + missing.join('\n') + '\n');
+    console.error(`  ✅ Updated .gitignore (added ${missing.length} entries)`);
+  }
+
+  // 3. Init git + first push
+  await pushGitBackup(remoteUrl, layer);
+
+  // 4. Install scheduled backup
+  const platform = os.platform();
+  const nodeBin = process.execPath;
+  const trBin = path.join(path.dirname(nodeBin), 'total-recall');
+  const label = isGlobal ? 'com.totalrecall.backup.global' : `com.totalrecall.backup.${projectName}`;
+
+  if (platform === 'darwin') {
+    // macOS: launchd plist
+    const plistDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+    fs.mkdirSync(plistDir, { recursive: true });
+    const logName = isGlobal ? 'backup-global.log' : `backup-${projectName}.log`;
+    const logsDir = path.join(os.homedir(), '.agent', 'logs');
+    fs.mkdirSync(logsDir, { recursive: true });
+
+    // Stagger times: global=2:30, projects get 2:00 + hash-based offset
+    const minute = isGlobal ? 30 : (projectName.split('').reduce((a, c) => a + c.charCodeAt(0), 0) % 30);
+
+    const plist = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${label}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodeBin}</string>
+    <string>${trBin}</string>
+    <string>backup</string>
+    <string>--push-git</string>
+    <string>${remoteUrl}</string>
+  </array>
+  <key>WorkingDirectory</key>
+  <string>${projectDir}</string>
+  <key>StartCalendarInterval</key>
+  <dict>
+    <key>Hour</key>
+    <integer>2</integer>
+    <key>Minute</key>
+    <integer>${minute}</integer>
+  </dict>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+    <key>PATH</key>
+    <string>${path.dirname(nodeBin)}:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${path.join(logsDir, logName)}</string>
+  <key>StandardErrorPath</key>
+  <string>${path.join(logsDir, logName)}</string>
+  <key>RunAtLoad</key>
+  <false/>
+</dict>
+</plist>`;
+
+    const plistPath = path.join(plistDir, `${label}.plist`);
+    fs.writeFileSync(plistPath, plist);
+
+    // Unload if exists, then load
+    spawnSync('launchctl', ['remove', label], { stdio: 'pipe' });
+    const load = spawnSync('launchctl', ['load', '-w', plistPath], { stdio: 'pipe' });
+    if (load.status === 0) {
+      console.error(`  ✅ Installed daily backup (2:${String(minute).padStart(2, '0')} AM)`);
+    } else {
+      console.error(`  ⚠️  launchctl load returned ${load.status} — plist saved, may need manual load`);
+    }
+
+  } else if (platform === 'linux') {
+    // Linux: cron job
+    const cronLine = `0 2 * * * ${nodeBin} ${trBin} backup --push-git ${remoteUrl} >> ${path.join(os.homedir(), '.agent', 'logs', 'backup.log')} 2>&1`;
+    const existing = spawnSync('crontab', ['-l'], { stdio: 'pipe' });
+    const currentCron = existing.stdout?.toString() || '';
+    if (!currentCron.includes(repoName)) {
+      const newCron = currentCron.trimEnd() + '\n' + cronLine + '\n';
+      const install = spawnSync('crontab', ['-'], { input: newCron, stdio: 'pipe' });
+      if (install.status === 0) {
+        console.error('  ✅ Installed daily cron job (2:00 AM)');
+      } else {
+        console.error('  ⚠️  Could not install cron job — add manually:');
+        console.error(`     ${cronLine}`);
+      }
+    } else {
+      console.error('  ✅ Cron job already exists');
+    }
+  }
+
+  console.error(`\n  🎉 Backup fully installed!`);
+  console.error(`     Repo:     github.com/${ghUser}/${repoName}`);
+  console.error(`     Schedule: Daily at 2:${platform === 'darwin' ? 'XX' : '00'} AM`);
+  console.error(`     Manual:   total-recall backup --push-git ${remoteUrl}`);
+}
+
 export default async function backup(args) {
   const opts = parseArgs(args);
   const SKILL_DIR = getSkillDir(opts.layer);
@@ -260,6 +425,12 @@ export default async function backup(args) {
     process.exit(1);
   }
 
+  // Install mode: full automatic setup
+  if (opts.install) {
+    await installBackup(opts.layer);
+    return;
+  }
+
   // Git-push mode: sovereign diff-based backup
   if (opts.pushGit) {
     await pushGitBackup(opts.pushGit, opts.layer);

package/src/cli/setup.mjs

@@ -456,6 +456,30 @@ export default async function setup(args) {
     }
   }
 
+  // ── Step 1.7: Install automatic brain backup ───────────────────────────────
+
+  hr();
+  console.log('\n  🔄 Automatic Brain Backup');
+  console.log('  Set up daily backup of your brain to a private GitHub repo.');
+  console.log('  Creates the repo, does the first push, and installs a scheduled job.\n');
+
+  const wantBackup = yes ? 'y' : (await prompt('Install automatic backup? [Y/n]:')).toLowerCase();
+  if (wantBackup !== 'n' && wantBackup !== 'no') {
+    if (!dryRun) {
+      try {
+        const backupHandler = await import(path.join(__dirname, 'backup.mjs'));
+        await backupHandler.default(['--install']);
+      } catch (e) {
+        warn(`Backup install failed: ${e.message}`);
+        warn('You can set it up later with: npx total-recall backup --install');
+      }
+    } else {
+      info('[dry-run] would run: total-recall backup --install');
+    }
+  } else {
+    info('Skipping auto-backup. Set it up later: npx total-recall backup --install');
+  }
+
   // ── Step 2: Provider-specific provisioning ──────────────────────────────────
 
   if (deployTarget === 'hetzner') {

package/src/server/rest.mjs

@@ -1623,6 +1623,45 @@ router.get('/api/brains/:id/nodes', requireAuth, requireScope('ssss:read', 'memo
  */
 router.get('/api/gemini-models', requireAuth, async (req, res) => {
   try {
+    // 1. Dynamically fetch available models from the antigravity CLI at runtime
+    try {
+      const { findBinaryInPath } = await import('../core/runtime.mjs');
+      const antigravityPath = findBinaryInPath('antigravity');
+      if (antigravityPath) {
+        const result = spawnSync(antigravityPath, ['--help'], { encoding: 'utf8', timeout: 3000 });
+        if (result.status === 0 && result.stdout) {
+          const output = result.stdout;
+          const discovered = [];
+
+          // Match standard gemini-X.Y-Z names
+          const modelRegex = /gemini-\d+\.\d+(?:-\w+)?/g;
+          const matches = output.match(modelRegex) || [];
+          for (const m of matches) {
+            discovered.push(m);
+          }
+
+          // Match version-style models like X.Y-pro or X.Y-flash and prefix with gemini-
+          const versionRegex = /\b(\d+\.\d+-\w+)\b/g;
+          const versionMatches = output.match(versionRegex) || [];
+          for (const vm of versionMatches) {
+            discovered.push(`gemini-${vm}`);
+          }
+
+          const uniqueModels = [...new Set(discovered)];
+          if (uniqueModels.length > 0) {
+            const cliModels = uniqueModels.map(modelId => {
+              const parts = modelId.split('-');
+              const displayName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
+              return { id: modelId, displayName };
+            });
+            return res.json({ models: cliModels, source: 'cli' });
+          }
+        }
+      }
+    } catch (e) {
+      // Fail silently and fall back
+    }
+
     let apiKey = process.env.GOOGLE_API_KEY;
     if (!apiKey) {
       // Find GOOGLE_API_KEY in upwards .env files
@@ -1647,14 +1686,9 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
     }
 
     const fallbackModels = [
-      { id: 'gemini-2.5-flash', displayName: 'Gemini 2.5 Flash' },
-      { id: 'gemini-2.5-pro', displayName: 'Gemini 2.5 Pro' },
-      { id: 'gemini-1.5-pro', displayName: 'Gemini 1.5 Pro' },
-      { id: 'gemini-1.5-flash', displayName: 'Gemini 1.5 Flash' },
       { id: 'gemini-3.5-flash', displayName: 'Gemini 3.5 Flash' },
-      { id: 'gemini-3.1-flash-lite', displayName: 'Gemini 3.1 Flash Lite' },
-      { id: 'gemini-2.0-flash-lite', displayName: 'Gemini 2.0 Flash Lite' },
-      { id: 'gemini-pro-latest', displayName: 'Gemini Pro Latest' }
+      { id: 'gemini-3.1-pro-preview', displayName: 'Gemini 3.1 Pro Preview' },
+      { id: 'gemini-3.1-flash-lite', displayName: 'Gemini 3.1 Flash Lite' }
     ];
 
     if (!apiKey) {
@@ -1679,6 +1713,21 @@ router.get('/api/gemini-models', requireAuth, async (req, res) => {
             const parts = id.split('-');
             const displayName = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join(' ');
             return { id, displayName };
+          })
+          .filter(m => {
+            // Only keep Gemini 3.1 and newer models
+            const match = m.id.match(/^gemini-(\d+)\.(\d+)/);
+            if (match) {
+              const major = parseInt(match[1], 10);
+              const minor = parseInt(match[2], 10);
+              return major > 3 || (major === 3 && minor >= 1);
+            }
+            const majorMatch = m.id.match(/^gemini-(\d+)/);
+            if (majorMatch) {
+              const major = parseInt(majorMatch[1], 10);
+              return major >= 3;
+            }
+            return false;
           });
         if (models.length > 0) {
           return res.json({ models, source: 'dynamic' });