total-recall-brain 3.26.0 → 3.28.0

package/src/cli/plugin/install.mjs

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawnSync } from 'node:child_process';
+import { validatePluginManifest } from '../../core/plugin-loader.mjs';
+import { CURATED_CATALOG } from '../../server/routes/plugins.mjs';
+
+export async function installPlugin(args = []) {
+  const isGlobal = args.includes('--global') || args.includes('-g');
+  const isLink = args.includes('--link') || args.includes('-l');
+  const cleanArgs = args.filter(a => a !== '--global' && a !== '-g' && a !== '--link' && a !== '-l');
+
+  let source = cleanArgs[0];
+  if (source) {
+    const matched = CURATED_CATALOG.find(p => p.id.toLowerCase() === source.toLowerCase());
+    if (matched) {
+      console.log(`📦 Resolving plugin '${matched.id}' from catalog: ${matched.sourceUrl}`);
+      source = matched.sourceUrl;
+    }
+  }
+
+  if (!source) {
+    console.error('❌ Error: Missing plugin source path or git URL.');
+    console.error('   Usage: total-recall plugin install <path|git-url> [--link] [--global]\n');
+    process.exit(1);
+  }
+
+  const pluginsBaseDir = isGlobal
+    ? path.join(os.homedir(), '.agent', 'plugins')
+    : path.join(process.cwd(), '.agent', 'plugins');
+
+  if (!fs.existsSync(pluginsBaseDir)) {
+    fs.mkdirSync(pluginsBaseDir, { recursive: true });
+  }
+
+  const isGitUrl = source.startsWith('http://') ||
+                   source.startsWith('https://') ||
+                   source.startsWith('git@') ||
+                   source.endsWith('.git');
+
+  if (isGitUrl) {
+    console.log(`Cloning plugin from ${source}...`);
+    const tempDir = path.join(os.tmpdir(), `tr-plugin-${Date.now()}`);
+    const cloneRes = spawnSync('git', ['clone', '--depth', '1', source, tempDir], {
+      stdio: 'inherit',
+      encoding: 'utf8'
+    });
+
+    if (cloneRes.status !== 0) {
+      console.error(`❌ Failed to clone repository from ${source}`);
+      process.exit(1);
+    }
+
+    const manifestPath = path.join(tempDir, 'plugin.json');
+    if (!fs.existsSync(manifestPath)) {
+      console.error(`❌ Cloned repository does not contain a plugin.json manifest`);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      process.exit(1);
+    }
+
+    let manifest;
+    try {
+      manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    } catch (err) {
+      console.error(`❌ Failed to parse plugin.json: ${err.message}`);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      process.exit(1);
+    }
+
+    const validation = validatePluginManifest(manifest);
+    if (!validation.valid) {
+      console.error(`❌ Invalid plugin manifest:`);
+      for (const e of validation.errors) {
+        console.error(`   - ${e}`);
+      }
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      process.exit(1);
+    }
+
+    const destDir = path.join(pluginsBaseDir, manifest.id);
+    if (fs.existsSync(destDir)) {
+      console.error(`❌ Plugin '${manifest.id}' already exists at ${destDir}. Remove it first.`);
+      fs.rmSync(tempDir, { recursive: true, force: true });
+      process.exit(1);
+    }
+
+    fs.cpSync(tempDir, destDir, { recursive: true });
+    fs.rmSync(tempDir, { recursive: true, force: true });
+
+    console.log(`\n✅ Successfully installed plugin '${manifest.name}' (id: ${manifest.id}, v${manifest.version})`);
+    console.log(`   Location: ${destDir}\n`);
+    return;
+  }
+
+  // Local directory install / link
+  const absSource = path.resolve(process.cwd(), source);
+  if (!fs.existsSync(absSource)) {
+    console.error(`❌ Source directory not found: ${absSource}`);
+    process.exit(1);
+  }
+
+  const manifestPath = path.join(absSource, 'plugin.json');
+  if (!fs.existsSync(manifestPath)) {
+    console.error(`❌ Directory '${absSource}' does not contain a plugin.json manifest`);
+    process.exit(1);
+  }
+
+  let manifest;
+  try {
+    manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+  } catch (err) {
+    console.error(`❌ Failed to parse plugin.json: ${err.message}`);
+    process.exit(1);
+  }
+
+  const validation = validatePluginManifest(manifest);
+  if (!validation.valid) {
+    console.error(`❌ Invalid plugin manifest:`);
+    for (const e of validation.errors) {
+      console.error(`   - ${e}`);
+    }
+    process.exit(1);
+  }
+
+  const destDir = path.join(pluginsBaseDir, manifest.id);
+
+  if (fs.existsSync(destDir)) {
+    console.error(`❌ Plugin '${manifest.id}' is already installed at ${destDir}. Remove it first.`);
+    process.exit(1);
+  }
+
+  if (isLink) {
+    fs.symlinkSync(absSource, destDir, 'junction');
+    console.log(`\n✅ Linked plugin '${manifest.name}' (id: ${manifest.id}, v${manifest.version})`);
+    console.log(`   Symlink: ${destDir} -> ${absSource}\n`);
+  } else {
+    fs.cpSync(absSource, destDir, { recursive: true });
+    console.log(`\n✅ Copied plugin '${manifest.name}' (id: ${manifest.id}, v${manifest.version})`);
+    console.log(`   Location: ${destDir}\n`);
+  }
+}

package/src/cli/plugin/list.mjs

@@ -0,0 +1,83 @@
+import { discoverPlugins } from '../../core/plugin-loader.mjs';
+
+function stripAnsi(str) {
+  return String(str || '').replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function padAnsi(str, targetLen) {
+  const visibleLen = stripAnsi(str).length;
+  const paddingNeeded = Math.max(0, targetLen - visibleLen);
+  return String(str || '') + ' '.repeat(paddingNeeded);
+}
+
+export async function listPlugins(args = []) {
+  const isJson = args.includes('--json');
+  const projectRoot = process.cwd();
+  const plugins = discoverPlugins(projectRoot);
+
+  if (isJson) {
+    console.log(JSON.stringify(plugins, null, 2));
+    return;
+  }
+
+  console.log(`\n🔌 Total Recall — Installed Plugins\n`);
+
+  if (plugins.length === 0) {
+    console.log('  No plugins installed in this project or globally (~/.agent/plugins/).');
+    console.log('  Install one with: npx total-recall plugin install <path|git-url>\n');
+    return;
+  }
+
+  const colId = 20;
+  const colName = 28;
+  const colVer = 10;
+  const colStatus = 12;
+  const colCats = 24;
+
+  const topBorder = `┌${'─'.repeat(colId + 2)}┬${'─'.repeat(colName + 2)}┬${'─'.repeat(colVer + 2)}┬${'─'.repeat(colStatus + 2)}┬${'─'.repeat(colCats + 2)}┐`;
+  const midBorder = `├${'─'.repeat(colId + 2)}┼${'─'.repeat(colName + 2)}┼${'─'.repeat(colVer + 2)}┼${'─'.repeat(colStatus + 2)}┼${'─'.repeat(colCats + 2)}┤`;
+  const botBorder = `└${'─'.repeat(colId + 2)}┴${'─'.repeat(colName + 2)}┴${'─'.repeat(colVer + 2)}┴${'─'.repeat(colStatus + 2)}┴${'─'.repeat(colCats + 2)}┘`;
+
+  console.log(topBorder);
+  console.log(
+    `│ ${padAnsi('Plugin ID', colId)} │ ` +
+    `${padAnsi('Name', colName)} │ ` +
+    `${padAnsi('Version', colVer)} │ ` +
+    `${padAnsi('Status', colStatus)} │ ` +
+    `${padAnsi('SSSS Categories', colCats)} │`
+  );
+  console.log(midBorder);
+
+  for (const p of plugins) {
+    const id = p.id;
+    const name = (p.manifest.name || id).slice(0, colName);
+    const ver = p.manifest.version ? `v${p.manifest.version}` : '—';
+    const status = p.valid ? '\x1b[32mActive ✅\x1b[0m' : '\x1b[31mInvalid ❌\x1b[0m';
+    const cats = (p.manifest.ssss_schemas?.categories || []).map(c => c.name).join(', ') || '—';
+    const catStr = cats.length > colCats ? cats.slice(0, colCats - 3) + '...' : cats;
+
+    console.log(
+      `│ \x1b[1m${padAnsi(id, colId)}\x1b[0m │ ` +
+      `${padAnsi(name, colName)} │ ` +
+      `${padAnsi(ver, colVer)} │ ` +
+      `${padAnsi(status, colStatus)} │ ` +
+      `${padAnsi(catStr, colCats)} │`
+    );
+  }
+
+  console.log(botBorder);
+
+  // Show detailed validation errors if any
+  const invalid = plugins.filter(p => !p.valid);
+  if (invalid.length > 0) {
+    console.log(`\n⚠️  Configuration Warnings:`);
+    for (const inv of invalid) {
+      console.log(`  Plugin '${inv.id}':`);
+      for (const err of inv.errors) {
+        console.log(`    - ${err}`);
+      }
+    }
+  }
+
+  console.log();
+}

package/src/cli/plugin/remove.mjs

@@ -0,0 +1,51 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export async function removePlugin(args = []) {
+  const isGlobal = args.includes('--global') || args.includes('-g');
+  const cleanArgs = args.filter(a => a !== '--global' && a !== '-g');
+
+  const id = cleanArgs[0];
+
+  if (!id) {
+    console.error('❌ Error: Missing plugin ID to remove.');
+    console.error('   Usage: total-recall plugin remove <id> [--global]\n');
+    process.exit(1);
+  }
+
+  const searchDirs = isGlobal
+    ? [path.join(os.homedir(), '.agent', 'plugins')]
+    : [
+        path.join(process.cwd(), '.agent', 'plugins'),
+        path.join(os.homedir(), '.agent', 'plugins')
+      ];
+
+  let targetPath = null;
+  for (const dir of searchDirs) {
+    const candidate = path.join(dir, id);
+    if (fs.existsSync(candidate)) {
+      targetPath = candidate;
+      break;
+    }
+  }
+
+  if (!targetPath) {
+    console.error(`❌ Plugin '${id}' was not found in installed plugin directories.`);
+    process.exit(1);
+  }
+
+  try {
+    const stat = fs.lstatSync(targetPath);
+    if (stat.isSymbolicLink()) {
+      fs.unlinkSync(targetPath);
+      console.log(`\n✅ Unlinked plugin '${id}' from ${targetPath}\n`);
+    } else {
+      fs.rmSync(targetPath, { recursive: true, force: true });
+      console.log(`\n✅ Removed plugin '${id}' from ${targetPath}\n`);
+    }
+  } catch (err) {
+    console.error(`❌ Failed to remove plugin '${id}': ${err.message}`);
+    process.exit(1);
+  }
+}

package/src/cli/plugin/search.mjs

@@ -0,0 +1,37 @@
+import { CURATED_CATALOG } from "../../server/routes/plugins.mjs";
+
+export async function searchCatalog(args = []) {
+  const isJson = args.includes("--json");
+  const cleanArgs = args.filter(a => a !== "--json");
+  const query = cleanArgs.join(" ").toLowerCase().trim();
+
+  let results = CURATED_CATALOG;
+  if (query) {
+    results = CURATED_CATALOG.filter(p =>
+      p.id.toLowerCase().includes(query) ||
+      p.name.toLowerCase().includes(query) ||
+      p.description.toLowerCase().includes(query) ||
+      p.tags.some(t => t.toLowerCase().includes(query))
+    );
+  }
+
+  if (isJson) {
+    console.log(JSON.stringify(results, null, 2));
+    return;
+  }
+
+  console.log("\n🔌 Total Recall — Plugin Catalog & Discovery\n");
+  if (results.length === 0) {
+    console.log("No plugins found matching \"" + query + "\".\n");
+    return;
+  }
+
+  for (const p of results) {
+    const verifiedBadge = p.verified ? " [Verified]" : "";
+    console.log("\x1b[1;36m● " + p.name + "\x1b[0m (id: \x1b[33m" + p.id + "\x1b[0m, v" + p.version + ")" + verifiedBadge);
+    console.log("  Rating:      ★ " + p.rating + " (" + p.reviewCount + " reviews) | Installs: " + p.installCount);
+    console.log("  Description: " + p.description);
+    console.log("  Tags:        " + p.tags.join(", "));
+    console.log("  Install:     \x1b[32mnpx total-recall plugin install " + p.sourceUrl + "\x1b[0m\n");
+  }
+}

package/src/cli/skill-projection.mjs

@@ -58,6 +58,20 @@ export const IDE_SKILLS = [
     // project-local dir, so project skills are opt-in (namespaced) via connect.
     project: null,
     global:  { dir: ['.codex', 'skills'], markers: ['.codex'] }
+  },
+  {
+    id: 'hermes',
+    label: 'Hermes Agent',
+    clients: ['hermes', 'hermes-agent'],
+    project: { dir: ['.hermes', 'skills'], markers: ['.hermes'], env: ['HERMES_AGENT', 'HERMES_HOME'] },
+    global:  { dir: ['.hermes', 'skills'], markers: ['.hermes'] }
+  },
+  {
+    id: 'dsh',
+    label: 'DeepSeek Harness',
+    clients: ['dsh', 'deepseek-harness', 'deepseek'],
+    project: { dir: ['.agents', 'skills'], markers: ['.dsh', '.agents'], env: ['DSH_AGENT', 'DEEPSEEK_HARNESS'] },
+    global:  { dir: ['.dsh', 'skills'], markers: ['.dsh'] }
   }
 ];
 

package/src/cli/wizard.html

@@ -1188,6 +1188,15 @@
             </div>
             <span class="ide-check">✓</span>
           </label>
+          <label class="ide-card" id="ide-dsh">
+            <input type="checkbox" value="dsh" onchange="toggleIde(this)">
+            <span class="ide-icon">⚡</span>
+            <div>
+              <div class="ide-name">DeepSeek Harness (dsh)</div>
+              <div class="ide-desc">DeepSeek AI — AGENTS.md + ~/.dsh/memory/MEMORY.md</div>
+            </div>
+            <span class="ide-check">✓</span>
+          </label>
           <label class="ide-card" id="ide-openclaw">
             <input type="checkbox" value="openclaw" onchange="toggleIde(this)">
             <span class="ide-icon">🦀</span>

package/src/core/agent-manager.mjs

@@ -0,0 +1,290 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { spawn } from 'node:child_process';
+import { HARNESS_SPECS, detectHarnesses } from './meta-harness.mjs';
+import { findBinaryInPath } from './runtime.mjs';
+import { logger } from './logger.mjs';
+
+function resolveStateDir() {
+  const stateDir = path.join(os.homedir(), '.agent', 'state');
+  if (!fs.existsSync(stateDir)) {
+    fs.mkdirSync(stateDir, { recursive: true });
+  }
+  return stateDir;
+}
+
+function resolveLogDir() {
+  const logDir = path.join(os.homedir(), '.agent', 'logs', 'agents');
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+
+function getStateFilePath() {
+  return path.join(resolveStateDir(), 'active-agents.json');
+}
+
+export function loadAgentState() {
+  const stateFile = getStateFilePath();
+  if (!fs.existsSync(stateFile)) return [];
+  try {
+    const raw = fs.readFileSync(stateFile, 'utf8');
+    const list = JSON.parse(raw);
+    return Array.isArray(list) ? list : [];
+  } catch {
+    return [];
+  }
+}
+
+export function saveAgentState(list) {
+  const stateFile = getStateFilePath();
+  try {
+    fs.writeFileSync(stateFile, JSON.stringify(list, null, 2), 'utf8');
+  } catch (err) {
+    logger.error('Failed to save agent state:', err.message);
+  }
+}
+
+export function isProcessRunning(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+/**
+ * List all active/recent spawned agents, pruning defunct processes.
+ */
+export function listAgents() {
+  const agents = loadAgentState();
+  const updated = [];
+
+  for (const a of agents) {
+    if (a.remote) {
+      updated.push(a);
+      continue;
+    }
+    const alive = isProcessRunning(a.pid);
+    if (alive) {
+      updated.push({ ...a, status: 'running' });
+    } else {
+      updated.push({ ...a, status: a.status === 'running' ? 'stopped' : a.status });
+    }
+  }
+
+  saveAgentState(updated);
+  return updated;
+}
+
+/**
+ * Spawn an agent harness headlessly or in background detach mode.
+ */
+export async function spawnAgent(harnessId, taskPrompt, options = {}) {
+  const spec = HARNESS_SPECS[harnessId];
+  if (!spec) {
+    throw new Error(`Unknown harness ID "${harnessId}". Available: ${Object.keys(HARNESS_SPECS).join(', ')}`);
+  }
+
+  // Remote mesh execution branch
+  if (options.node) {
+    const { findMeshNode, getMeshSelf, execMeshCommand } = await import('./mesh.mjs');
+    const targetNode = findMeshNode(options.node, options.vaultRoot);
+    if (!targetNode) {
+      throw new Error(`Target mesh node "${options.node}" not found in mesh topology.`);
+    }
+    const selfNode = getMeshSelf();
+    const isSelf = targetNode.self || (selfNode && targetNode.ip === selfNode.ip);
+
+    if (!isSelf) {
+      const id = `agent-${harnessId}-${Date.now().toString(36)}`;
+      const remoteCmd = `total-recall agent spawn ${harnessId} ${JSON.stringify(taskPrompt)} ${options.name ? `--name ${JSON.stringify(options.name)}` : ''} --json`;
+      const execResult = await execMeshCommand(options.node, remoteCmd, {
+        vaultRoot: options.vaultRoot,
+      });
+
+      let remoteRecord = null;
+      try {
+        const jsonMatch = execResult.stdout.match(/\{[\s\S]*\}/);
+        if (jsonMatch) remoteRecord = JSON.parse(jsonMatch[0]);
+      } catch {}
+
+      const record = {
+        ...(remoteRecord || {}),
+        id: remoteRecord?.id || id,
+        node: options.node,
+        remote: true,
+        status: execResult.success ? 'running' : 'failed',
+        startedAt: remoteRecord?.startedAt || new Date().toISOString(),
+        task: taskPrompt,
+        harness: harnessId,
+      };
+
+      const current = loadAgentState();
+      current.unshift(record);
+      saveAgentState(current);
+      return record;
+    }
+  }
+
+  const binPath = findBinaryInPath(spec.binary);
+  if (!binPath) {
+    throw new Error(`Binary "${spec.binary}" for harness "${spec.name}" not found on PATH.`);
+  }
+
+  const id = `agent-${harnessId}-${Date.now().toString(36)}`;
+  const logDir = resolveLogDir();
+  const logFile = path.join(logDir, `${id}.log`);
+  const logFd = fs.openSync(logFile, 'a');
+
+  const args = [...spec.defaultFlags, taskPrompt];
+  const cwd = options.cwd || process.cwd();
+
+  const child = spawn(binPath, args, {
+    cwd,
+    detached: options.detach !== false,
+    stdio: options.detach !== false ? ['ignore', logFd, logFd] : 'pipe',
+    env: {
+      ...process.env,
+      TR_AGENT_ID: id,
+      TR_HARNESS: harnessId
+    }
+  });
+
+  const record = {
+    id,
+    name: options.name || `${spec.name} Worker`,
+    harness: harnessId,
+    binary: binPath,
+    pid: child.pid,
+    task: taskPrompt,
+    cwd,
+    logFile,
+    startedAt: new Date().toISOString(),
+    status: 'running',
+    detached: options.detach !== false
+  };
+
+  const current = loadAgentState();
+  current.unshift(record);
+  saveAgentState(current);
+
+  if (options.detach !== false) {
+    child.unref();
+    return record;
+  }
+
+  // Foreground execution
+  return new Promise((resolve, reject) => {
+    let output = '';
+    let errOutput = '';
+
+    child.stdout.on('data', (chunk) => {
+      output += chunk.toString();
+      fs.writeSync(logFd, chunk);
+    });
+
+    child.stderr.on('data', (chunk) => {
+      errOutput += chunk.toString();
+      fs.writeSync(logFd, chunk);
+    });
+
+    child.on('close', (code) => {
+      fs.closeSync(logFd);
+      const list = loadAgentState();
+      const item = list.find(x => x.id === id);
+      if (item) {
+        item.status = code === 0 ? 'completed' : 'failed';
+        item.exitCode = code;
+        item.endedAt = new Date().toISOString();
+        saveAgentState(list);
+      }
+      resolve({
+        ...record,
+        status: code === 0 ? 'completed' : 'failed',
+        exitCode: code,
+        output: output.trim(),
+        stderr: errOutput.trim()
+      });
+    });
+
+    child.on('error', (err) => {
+      try { fs.closeSync(logFd); } catch {}
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Kill a running agent by ID or PID.
+ */
+export async function killAgent(idOrPid) {
+  const list = loadAgentState();
+  const target = list.find(a => a.id === idOrPid || String(a.pid) === String(idOrPid));
+
+  if (!target) {
+    throw new Error(`Agent "${idOrPid}" not found in active agent registry.`);
+  }
+
+  if (target.remote && target.node) {
+    const { execMeshCommand } = await import('./mesh.mjs');
+    const remoteCmd = `total-recall agent kill ${target.id}`;
+    await execMeshCommand(target.node, remoteCmd);
+    target.status = 'killed';
+    target.endedAt = new Date().toISOString();
+    saveAgentState(list);
+    return { success: true, message: `Terminated remote agent ${target.id} on mesh node "${target.node}"` };
+  }
+
+  if (isProcessRunning(target.pid)) {
+    try {
+      process.kill(target.pid, 'SIGTERM');
+      target.status = 'killed';
+      target.endedAt = new Date().toISOString();
+      saveAgentState(list);
+      return { success: true, message: `Terminated agent ${target.id} (PID ${target.pid})` };
+    } catch (err) {
+      throw new Error(`Failed to kill process ${target.pid}: ${err.message}`);
+    }
+  } else {
+    target.status = 'stopped';
+    saveAgentState(list);
+    return { success: true, message: `Agent ${target.id} was already stopped.` };
+  }
+}
+
+/**
+ * Get recent log output for an agent.
+ */
+export async function getAgentLogs(idOrPid, tailLines = 50) {
+  const list = loadAgentState();
+  const target = list.find(a => a.id === idOrPid || String(a.pid) === String(idOrPid));
+
+  if (!target) {
+    throw new Error(`Agent "${idOrPid}" not found.`);
+  }
+
+  if (target.remote && target.node) {
+    const { execMeshCommand } = await import('./mesh.mjs');
+    const remoteCmd = `total-recall agent logs ${target.id} --tail ${tailLines}`;
+    const res = await execMeshCommand(target.node, remoteCmd);
+    return res.stdout || res.stderr || '(No logs returned from remote node)';
+  }
+
+  if (!fs.existsSync(target.logFile)) {
+    return '(No log file found for this agent)';
+  }
+
+  try {
+    const raw = fs.readFileSync(target.logFile, 'utf8');
+    const lines = raw.split('\n');
+    return lines.slice(-tailLines).join('\n');
+  } catch (err) {
+    return `Error reading logs: ${err.message}`;
+  }
+}
+