total-recall-brain 3.1.0

package/src/cli/reset-password.mjs

@@ -0,0 +1,75 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import bcrypt from 'bcrypt';
+import yaml from 'yaml';
+import { BCRYPT_COST } from '../server/auth.mjs';
+import { brainDir } from '../core/config.mjs';
+
+export default async function resetPassword(args) {
+  if (args.includes('--help') || args.includes('-h') || args.length === 0) {
+    console.log(`
+  total-recall reset-password "new_password"
+
+  Resets the dashboard admin password in ~/.agent/skills/total-recall/config/security.yml.
+  Sets force_password_reset to true so you will be prompted to change it upon first login.
+`);
+    return;
+  }
+
+  const password = args.join(' ');
+  if (password.length < 8) {
+    console.error('Error: Password must be at least 8 characters.');
+    process.exit(1);
+  }
+
+  const configDir = path.join(brainDir, 'config');
+  const securityPath = path.join(configDir, 'security.yml');
+
+  // Enforce directories exist
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+
+  let config = {};
+  if (fs.existsSync(securityPath)) {
+    try {
+      config = yaml.parse(fs.readFileSync(securityPath, 'utf8')) || {};
+    } catch (e) {
+      console.warn('Warning: Could not parse existing security.yml, starting fresh.');
+    }
+  }
+
+  // Ensure default structures are present
+  if (!config.dashboard) {
+    config.dashboard = {};
+  }
+  if (!config.api) {
+    config.api = { pats: [], allow_static_pats: false };
+  }
+  if (!config.network) {
+    config.network = { require_https: true, public_health: false, allowed_origins: [] };
+  }
+  if (!config.bind) {
+    config.bind = { host: '127.0.0.1', port: 3000, allow_public_bind: false };
+  }
+
+  console.log('Hashing password...');
+  const hash = await bcrypt.hash(password, BCRYPT_COST);
+
+
+  config.dashboard.password_hash = hash;
+  const isDefault = password === 'totalrecall';
+  config.dashboard.force_password_reset = isDefault;
+
+  fs.writeFileSync(securityPath, yaml.stringify(config), { encoding: 'utf8', mode: 0o600 });
+
+  console.log(`\n  ✅ Success! Dashboard admin password reset.`);
+  console.log(`  📍 Saved to: ${securityPath}`);
+  if (isDefault) {
+    console.log(`  🔑 Next login password: "${password}" (you will be forced to change it on login)`);
+    console.log(`  👉 Access your dashboard and enter this password to log in and set your permanent password.\n`);
+  } else {
+    console.log(`  🔑 Next login password: "${password}" (you can sign in directly now!)\n`);
+  }
+}

package/src/cli/restore.mjs

@@ -0,0 +1,135 @@
+/**
+ * total-recall restore
+ *
+ * Restore VFS from an encrypted or unencrypted backup tarball.
+ *
+ * Usage:
+ *   npx total-recall restore --from <path>
+ *
+ * Options:
+ *   --from <path>      Path to backup file (required)
+ *   --yes              Skip confirmation prompt
+ *   --help             Show this help
+ */
+
+import { spawn, spawnSync, execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { createInterface } from 'node:readline';
+
+import { resolveAgentDir, parseLayerFlag } from './agent-dir.mjs';
+
+/** Parent of the skill dir — where the tarball gets extracted to */
+function getExtractDir(layer = 'auto') {
+  return path.join(resolveAgentDir(layer), 'skills');
+}
+
+function commandExists(cmd) {
+  if (!cmd || !/^[a-zA-Z0-9_-]+$/.test(cmd)) {
+    return false;
+  }
+  try {
+    execFileSync('which', [cmd], { stdio: 'ignore' });
+    return true;
+  } catch { return false; }
+}
+
+function parseArgs(args) {
+  const { layer, remainingArgs } = parseLayerFlag(args);
+  const opts = { from: null, yes: false, help: false, layer };
+  for (let i = 0; i < remainingArgs.length; i++) {
+    switch (remainingArgs[i]) {
+      case '--from': opts.from = remainingArgs[++i]; break;
+      case '--yes': case '-y': opts.yes = true; break;
+      case '--help': case '-h': opts.help = true; break;
+    }
+  }
+  return opts;
+}
+
+function printHelp() {
+  console.log(`
+  total-recall restore — Restore VFS from a backup tarball
+
+  Usage: total-recall restore --from <path>
+
+  Options:
+    --from <path>      Path to backup file (required)
+    --yes, -y          Skip confirmation prompt
+    --help, -h         Show this help
+`);
+}
+
+async function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(message, (answer) => { rl.close(); resolve(answer.toLowerCase().startsWith('y')); });
+  });
+}
+
+export default async function restore(args) {
+  const opts = parseArgs(args);
+  if (opts.help) { printHelp(); return; }
+
+  if (!opts.from) {
+    console.error('  ❌ --from <path> is required');
+    printHelp();
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(opts.from)) {
+    console.error(`  ❌ Backup file not found: ${opts.from}`);
+    process.exit(1);
+  }
+
+  const isEncrypted = opts.from.endsWith('.gpg');
+  const extractDir = getExtractDir(opts.layer);
+
+  if (!opts.yes) {
+    console.error(`\n  ⚠️  This will overwrite .agent/skills/total-recall/ with the contents of:`);
+    console.error(`     ${opts.from}`);
+    const ok = await confirm('  Continue? (y/N) ');
+    if (!ok) { console.error('  Aborted.'); return; }
+  }
+
+  // Ensure the extract target exists
+  fs.mkdirSync(extractDir, { recursive: true });
+
+  console.error(`\n  📦 Restoring from backup...`);
+  console.error(`     Source:    ${opts.from}`);
+  console.error(`     Encrypted: ${isEncrypted}`);
+
+  try {
+    if (isEncrypted) {
+      if (!commandExists('gpg')) { console.error('  ❌ gpg not found'); process.exit(1); }
+      
+      const gpg = spawn('gpg', ['--decrypt', '--batch', opts.from], { stdio: ['ignore', 'pipe', 'inherit'] });
+      const tar = spawn('tar', ['-xf', '-', '-C', extractDir], { stdio: ['pipe', 'inherit', 'inherit'] });
+
+      gpg.stdout.pipe(tar.stdin);
+
+      const [gpgExit, tarExit] = await Promise.all([
+        new Promise((resolve) => gpg.on('close', resolve)),
+        new Promise((resolve) => tar.on('close', resolve))
+      ]);
+
+      if (gpgExit !== 0) throw new Error(`gpg failed (exit ${gpgExit})`);
+      if (tarExit !== 0) throw new Error(`tar failed (exit ${tarExit})`);
+    } else {
+      const result = spawnSync('tar', ['-xzf', opts.from, '-C', extractDir], { stdio: 'inherit' });
+      if (result.status !== 0) throw new Error(`tar failed (exit ${result.status})`);
+    }
+
+    console.error('  ✅ Files extracted');
+
+    // Reindex after restore
+    console.error('  🔄 Rebuilding indexes...');
+    const { default: compile } = await import('./compile.mjs');
+    await compile(['--quiet']);
+    console.error('  ✅ Restore complete\n');
+  } catch (err) {
+    console.error(`  ❌ Restore failed: ${err.message}`);
+    process.exit(1);
+  }
+}