total-recall-brain 3.6.4 → 3.6.6

package/src/server/rest.mjs

@@ -83,6 +83,10 @@ import { memoryRouter }   from './routes/memory.mjs';
 import { keysRouter }     from './routes/keys.mjs';
 import { sessionsRouter } from './routes/sessions.mjs';
 import { shareRouter }    from './routes/share.mjs';
+import { authRouter }     from './routes/auth.mjs';
+import { sandboxRouter }  from './routes/sandbox.mjs';
+import { researchRouter } from './routes/research.mjs';
+import { skillsRouter }   from './routes/skills.mjs';
 // ollamaUrl removed — CLI agents replace Ollama
 import {
   AGENT_DIR,
@@ -159,6 +163,10 @@ router.use(memoryRouter);
 router.use(keysRouter);
 router.use(sessionsRouter);
 router.use(shareRouter);
+router.use(authRouter);
+router.use(sandboxRouter);
+router.use(researchRouter);
+router.use(skillsRouter);
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -490,36 +498,7 @@ router.post('/api/diagnostics/agents', requireAuth, requireScope('health:read'),
 // ─── Keys ─────────── (moved to ./routes/keys.mjs)
 // ─── Sessions ─────── (moved to ./routes/sessions.mjs)
 // ─── Sandbox ──────────────────────────────────────────────────────────────────
-
-/**
- * POST /api/sandbox
- * Body: { code }
- */
-// Sandbox is rate-limited *before* requireAuth on purpose — limiter keys on
-// the authenticated principal when present, so it's IP-bucketed for
-// pre-auth misuse and key-bucketed once a PAT is attached.
-router.post('/api/sandbox', sandboxRateLimiter(), requireAuth, requireScope('sandbox:run'), requireSandboxEnabled, async (req, res) => {
-  try {
-    const { code } = req.body || {};
-    if (!code) return badRequest(res, 'code is required');
-
-    const tmpDir  = path.join(os.tmpdir(), 'total-recall-sandbox');
-    fs.mkdirSync(tmpDir, { recursive: true });
-    const script  = path.join(tmpDir, `rest-${Date.now()}.mjs`);
-    fs.writeFileSync(script, code);
-
-    const result = await runInSandbox(script, 15000);
-    try { fs.unlinkSync(script); } catch {}
-
-    res.json({
-      success: result.success,
-      exit_code: result.code,
-      output: result.output,
-    });
-  } catch (err) {
-    serverError(res, err);
-  }
-});
+// Moved to routes/sandbox.mjs
 
 // ─── Config ───────────────────────────────────────────────────────────────────
 
@@ -707,41 +686,7 @@ router.get('/api', (req, res) => {
 });
 
 // ─── Research Queue ───────────────────────────────────────────────────────────
-// Thin REST wrappers over src/core/research-queue.mjs
-
-router.get('/api/research', requireAuth, requireScope('memory:read'), (req, res) => {
-  try {
-    const { status, query, limit, offset } = req.query;
-    res.json(listQueue({ status, query, limit, offset }));
-  } catch (err) { serverError(res, err); }
-});
-
-router.post('/api/research', requireAuth, requireScope('memory:write'), (req, res) => {
-  try {
-    const { topic, priority, notes } = req.body || {};
-    if (!topic) return badRequest(res, 'topic is required');
-    res.status(201).json(addToQueue({ topic, priority, notes }));
-  } catch (err) { serverError(res, err); }
-});
-
-router.patch('/api/research/:id', requireAuth, requireScope('memory:write'), (req, res) => {
-  try {
-    res.json(updateQueueItem(req.params.id, req.body || {}));
-  } catch (err) {
-    if (err.status === 404) return notFound(res, err.message);
-    serverError(res, err);
-  }
-});
-
-router.delete('/api/research/:id', requireAuth, requireScope('memory:write'), (req, res) => {
-  try {
-    res.json(removeFromQueue(req.params.id));
-  } catch (err) {
-    if (err.status === 404) return notFound(res, err.message);
-    serverError(res, err);
-  }
-});
-
+// Moved to routes/research.mjs
 // ─── Active Integrations ──────────────────────────────────────────────────────
 
 /**
@@ -1098,110 +1043,7 @@ router.get('/api/files', requireAuth, requireScope('files:read'), (req, res) =>
   } catch (err) { serverError(res, err); }
 });
 
-router.get('/api/skills', requireAuth, requireScope('files:read', 'ssss:read'), (req, res) => {
-  try {
-    if (!fs.existsSync(SKILLS_DIR)) {
-      fs.mkdirSync(SKILLS_DIR, { recursive: true });
-    }
-    const skills = fs.readdirSync(SKILLS_DIR).map(dir => {
-      const dirPath = path.join(SKILLS_DIR, dir);
-      const stats = fs.statSync(dirPath);
-      
-      let subSkills = [];
-      const subSkillsPath = path.join(dirPath, 'skills');
-      if (fs.existsSync(subSkillsPath) && fs.statSync(subSkillsPath).isDirectory()) {
-        try {
-          subSkills = fs.readdirSync(subSkillsPath).filter(sd => 
-            fs.statSync(path.join(subSkillsPath, sd)).isDirectory()
-          );
-        } catch (e) {}
-      }
-
-      return {
-        name: dir,
-        size: stats.size,
-        modified: stats.mtime,
-        isDirectory: stats.isDirectory(),
-        subSkills
-      };
-    });
-    res.json(skills);
-  } catch (err) { serverError(res, err); }
-});
-
-router.get('/api/skills/search', requireAuth, requireScope('files:read', 'ssss:read'), async (req, res) => {
-  try {
-    const q = req.query.q || '';
-    if (!q) {
-      return res.status(400).json({ error: 'Missing search query parameter `q`.' });
-    }
-    const { searchAndSort } = await import('../../.agent/skills/total-recall/skills/skill/scripts/find-skills.mjs');
-    const results = searchAndSort(q);
-    res.json(results);
-  } catch (err) { serverError(res, err); }
-});
-
-router.post('/api/skills/install', requireAuth, requireScope('files:write', 'ssss:write'), async (req, res) => {
-  try {
-    const { pkg } = req.body;
-    if (!pkg) {
-      return res.status(400).json({ error: 'Missing required `pkg` body parameter.' });
-    }
-    const { installSkill } = await import('../../.agent/skills/total-recall/skills/skill/scripts/install-skill.mjs');
-    const result = installSkill(pkg);
-    res.json(result);
-  } catch (err) { serverError(res, err); }
-});
-
-router.get('/api/skills/:name', requireAuth, requireScope('files:read', 'ssss:read'), (req, res) => {
-  try {
-    const { name } = req.params;
-    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
-      return res.status(400).json({ error: 'Invalid skill name' });
-    }
-    const skillPath = path.join(SKILLS_DIR, name, 'SKILL.md');
-    if (!fs.existsSync(skillPath)) {
-      return res.status(404).json({ error: `Skill "${name}" not found` });
-    }
-    const content = fs.readFileSync(skillPath, 'utf8');
-    res.json({ name, content });
-  } catch (err) { serverError(res, err); }
-});
-
-router.put('/api/skills/:name', requireAuth, requireScope('files:write', 'ssss:write'), (req, res) => {
-  try {
-    const { name } = req.params;
-    const { content } = req.body;
-    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
-      return res.status(400).json({ error: 'Invalid skill name' });
-    }
-    if (typeof content !== 'string') {
-      return res.status(400).json({ error: 'Missing or invalid `content` field.' });
-    }
-    const skillDir = path.join(SKILLS_DIR, name);
-    if (!fs.existsSync(skillDir)) {
-      fs.mkdirSync(skillDir, { recursive: true });
-    }
-    const skillPath = path.join(skillDir, 'SKILL.md');
-    fs.writeFileSync(skillPath, content, 'utf8');
-    res.json({ success: true, message: `Skill "${name}" updated successfully` });
-  } catch (err) { serverError(res, err); }
-});
-
-router.delete('/api/skills/:name', requireAuth, requireScope('files:write', 'ssss:write'), (req, res) => {
-  try {
-    const { name } = req.params;
-    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
-      return res.status(400).json({ error: 'Invalid skill name' });
-    }
-    const skillDir = path.join(SKILLS_DIR, name);
-    if (!fs.existsSync(skillDir)) {
-      return res.status(404).json({ error: `Skill "${name}" not found` });
-    }
-    fs.rmSync(skillDir, { recursive: true, force: true });
-    res.json({ success: true, message: `Skill "${name}" deleted successfully` });
-  } catch (err) { serverError(res, err); }
-});
+// Moved to routes/skills.mjs
 
 // ─── Scripts Editor & Execution ───────────────────────────────────────────────
 
@@ -1345,6 +1187,12 @@ router.get('/api/tasks', requireAuth, requireScope('tasks:read'), (req, res) =>
       try {
         const raw = fs.readFileSync(path.join(TASKS_DIR, file), 'utf8');
         const { data, content } = matter(raw);
+        
+        // By default, filter out completed tasks
+        if (req.query.status !== 'all' && data.status === 'completed') {
+          continue;
+        }
+        
         tasks.push({ ...data, body: content.trim(), slug: file.replace('.md', '') });
       } catch (e) {
         // skip
@@ -1354,6 +1202,31 @@ router.get('/api/tasks', requireAuth, requireScope('tasks:read'), (req, res) =>
   } catch (err) { serverError(res, err); }
 });
 
+router.delete('/api/tasks/cleanup', requireAuth, requireScope('tasks:write'), (req, res) => {
+  try {
+    if (!fs.existsSync(TASKS_DIR)) {
+      return res.json({ deleted: 0 });
+    }
+    let deleted = 0;
+    const files = fs.readdirSync(TASKS_DIR);
+    for (const file of files) {
+      if (!file.endsWith('.md')) continue;
+      const filePath = path.join(TASKS_DIR, file);
+      try {
+        const raw = fs.readFileSync(filePath, 'utf8');
+        const { data } = matter(raw);
+        if (data.status === 'completed') {
+          fs.unlinkSync(filePath);
+          deleted++;
+        }
+      } catch (e) {
+        // skip
+      }
+    }
+    res.json({ deleted });
+  } catch (err) { serverError(res, err); }
+});
+
 router.post('/api/tasks', requireAuth, requireScope('tasks:write'), (req, res) => {
   try {
     const { category, target, body, priority = 5 } = req.body || {};
@@ -1559,26 +1432,7 @@ router.post('/api/capture/:source', requireAuth, requireScope('memory:write'), a
 });
 
 // ─── Consolidated Auth Routes ──────────────────────────────────────────────────
-
-router.post('/auth/login', loginHandler);
-router.post('/auth/logout', logoutHandler);
-router.post('/auth/change-password', requireAuth, changePasswordHandler);
-router.get('/auth/me', requireAuth, (req, res) => res.json({ authenticated: true }));
-
-router.get("/auth/status", (req, res) => {
-  const config = loadSecurityConfig();
-  const configured = !!config.dashboard?.password_hash;
-  res.json({ configured });
-});
-
-router.post("/auth/setup", async (req, res) => {
-  const config = loadSecurityConfig();
-  const alreadyConfigured = !!config.dashboard?.password_hash;
-  if (alreadyConfigured) {
-    return res.status(400).json({ error: "Dashboard password is already configured" });
-  }
-  return changePasswordHandler(req, res);
-});
+// Moved to routes/auth.mjs
 
 // ─── Voice / TTS (Kokoro / System) ───────────────────────────────────────────────
 

package/src/server/route-manifest.json

@@ -295,6 +295,10 @@
     "method": "POST",
     "path": "/api/tasks"
   },
+  {
+    "method": "DELETE",
+    "path": "/api/tasks/cleanup"
+  },
   {
     "method": "POST",
     "path": "/api/tts"

package/src/server/routes/auth.mjs

@@ -0,0 +1,32 @@
+import express from 'express';
+import {
+  requireAuth,
+  loadSecurityConfig,
+  loginHandler,
+  logoutHandler,
+  changePasswordHandler,
+} from '../auth.mjs';
+
+export const authRouter = express.Router();
+
+// ─── Consolidated Auth Routes ──────────────────────────────────────────────────
+
+authRouter.post('/auth/login', loginHandler);
+authRouter.post('/auth/logout', logoutHandler);
+authRouter.post('/auth/change-password', requireAuth, changePasswordHandler);
+authRouter.get('/auth/me', requireAuth, (req, res) => res.json({ authenticated: true }));
+
+authRouter.get("/auth/status", (req, res) => {
+  const config = loadSecurityConfig();
+  const configured = !!config.dashboard?.password_hash;
+  res.json({ configured });
+});
+
+authRouter.post("/auth/setup", async (req, res) => {
+  const config = loadSecurityConfig();
+  const alreadyConfigured = !!config.dashboard?.password_hash;
+  if (alreadyConfigured) {
+    return res.status(400).json({ error: "Dashboard password is already configured" });
+  }
+  return changePasswordHandler(req, res);
+});

package/src/server/routes/research.mjs

@@ -0,0 +1,55 @@
+import express from 'express';
+import { requireAuth, requireScope } from '../auth.mjs';
+import { listQueue, addToQueue, updateQueueItem, removeFromQueue } from '../../core/research-queue.mjs';
+import { logger } from '../../core/logger.mjs';
+
+function badRequest(res, msg) {
+  return res.status(400).json({ error: msg });
+}
+
+function notFound(res, msg) {
+  return res.status(404).json({ error: msg || 'Not found' });
+}
+
+function serverError(res, err) {
+  logger.error('research', 'Internal server error', { error: err.message, stack: err.stack });
+  return res.status(500).json({ error: 'Internal server error' });
+}
+
+export const researchRouter = express.Router();
+
+// ─── Research Queue ───────────────────────────────────────────────────────────
+// Thin REST wrappers over src/core/research-queue.mjs
+
+researchRouter.get('/api/research', requireAuth, requireScope('memory:read'), (req, res) => {
+  try {
+    const { status, query, limit, offset } = req.query;
+    res.json(listQueue({ status, query, limit, offset }));
+  } catch (err) { serverError(res, err); }
+});
+
+researchRouter.post('/api/research', requireAuth, requireScope('memory:write'), (req, res) => {
+  try {
+    const { topic, priority, notes } = req.body || {};
+    if (!topic) return badRequest(res, 'topic is required');
+    res.status(201).json(addToQueue({ topic, priority, notes }));
+  } catch (err) { serverError(res, err); }
+});
+
+researchRouter.patch('/api/research/:id', requireAuth, requireScope('memory:write'), (req, res) => {
+  try {
+    res.json(updateQueueItem(req.params.id, req.body || {}));
+  } catch (err) {
+    if (err.status === 404) return notFound(res, err.message);
+    serverError(res, err);
+  }
+});
+
+researchRouter.delete('/api/research/:id', requireAuth, requireScope('memory:write'), (req, res) => {
+  try {
+    res.json(removeFromQueue(req.params.id));
+  } catch (err) {
+    if (err.status === 404) return notFound(res, err.message);
+    serverError(res, err);
+  }
+});

package/src/server/routes/sandbox.mjs

@@ -0,0 +1,55 @@
+import express from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { runInSandbox } from '../../core/sandbox.mjs';
+import {
+  requireAuth,
+  requireScope,
+  sandboxRateLimiter,
+  requireSandboxEnabled,
+} from '../auth.mjs';
+import { logger } from '../../core/logger.mjs';
+
+function badRequest(res, msg) {
+  return res.status(400).json({ error: msg });
+}
+
+function serverError(res, err) {
+  logger.error('sandbox', 'Internal server error', { error: err.message, stack: err.stack });
+  return res.status(500).json({ error: 'Internal server error' });
+}
+
+export const sandboxRouter = express.Router();
+
+// ─── Sandbox ──────────────────────────────────────────────────────────────────
+
+/**
+ * POST /api/sandbox
+ * Body: { code }
+ */
+// Sandbox is rate-limited *before* requireAuth on purpose — limiter keys on
+// the authenticated principal when present, so it's IP-bucketed for
+// pre-auth misuse and key-bucketed once a PAT is attached.
+sandboxRouter.post('/api/sandbox', sandboxRateLimiter(), requireAuth, requireScope('sandbox:run'), requireSandboxEnabled, async (req, res) => {
+  try {
+    const { code } = req.body || {};
+    if (!code) return badRequest(res, 'code is required');
+
+    const tmpDir  = path.join(os.tmpdir(), 'total-recall-sandbox');
+    fs.mkdirSync(tmpDir, { recursive: true });
+    const script  = path.join(tmpDir, `rest-${Date.now()}.mjs`);
+    fs.writeFileSync(script, code);
+
+    const result = await runInSandbox(script, 15000);
+    try { fs.unlinkSync(script); } catch {}
+
+    res.json({
+      success: result.success,
+      exit_code: result.code,
+      output: result.output,
+    });
+  } catch (err) {
+    serverError(res, err);
+  }
+});

package/src/server/routes/skills.mjs

@@ -0,0 +1,118 @@
+import express from 'express';
+import fs from 'node:fs';
+import path from 'node:path';
+import { requireAuth, requireScope } from '../auth.mjs';
+import { logger } from '../../core/logger.mjs';
+import { SKILLS_DIR } from './_shared.mjs';
+
+function serverError(res, err) {
+  logger.error('skills', 'Internal server error', { error: err.message, stack: err.stack });
+  return res.status(500).json({ error: 'Internal server error' });
+}
+
+export const skillsRouter = express.Router();
+
+skillsRouter.get('/api/skills', requireAuth, requireScope('files:read', 'ssss:read'), (req, res) => {
+  try {
+    if (!fs.existsSync(SKILLS_DIR)) {
+      fs.mkdirSync(SKILLS_DIR, { recursive: true });
+    }
+    const skills = fs.readdirSync(SKILLS_DIR).map(dir => {
+      const dirPath = path.join(SKILLS_DIR, dir);
+      const stats = fs.statSync(dirPath);
+      
+      let subSkills = [];
+      const subSkillsPath = path.join(dirPath, 'skills');
+      if (fs.existsSync(subSkillsPath) && fs.statSync(subSkillsPath).isDirectory()) {
+        try {
+          subSkills = fs.readdirSync(subSkillsPath).filter(sd => 
+            fs.statSync(path.join(subSkillsPath, sd)).isDirectory()
+          );
+        } catch (e) {}
+      }
+
+      return {
+        name: dir,
+        size: stats.size,
+        modified: stats.mtime,
+        isDirectory: stats.isDirectory(),
+        subSkills
+      };
+    });
+    res.json(skills);
+  } catch (err) { serverError(res, err); }
+});
+
+skillsRouter.get('/api/skills/search', requireAuth, requireScope('files:read', 'ssss:read'), async (req, res) => {
+  try {
+    const q = req.query.q || '';
+    if (!q) {
+      return res.status(400).json({ error: 'Missing search query parameter `q`.' });
+    }
+    const { searchAndSort } = await import('../../../.agent/skills/total-recall/skills/skill/scripts/find-skills.mjs');
+    const results = searchAndSort(q);
+    res.json(results);
+  } catch (err) { serverError(res, err); }
+});
+
+skillsRouter.post('/api/skills/install', requireAuth, requireScope('files:write', 'ssss:write'), async (req, res) => {
+  try {
+    const { pkg } = req.body;
+    if (!pkg) {
+      return res.status(400).json({ error: 'Missing required `pkg` body parameter.' });
+    }
+    const { installSkill } = await import('../../../.agent/skills/total-recall/skills/skill/scripts/install-skill.mjs');
+    const result = installSkill(pkg);
+    res.json(result);
+  } catch (err) { serverError(res, err); }
+});
+
+skillsRouter.get('/api/skills/:name', requireAuth, requireScope('files:read', 'ssss:read'), (req, res) => {
+  try {
+    const { name } = req.params;
+    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
+      return res.status(400).json({ error: 'Invalid skill name' });
+    }
+    const skillPath = path.join(SKILLS_DIR, name, 'SKILL.md');
+    if (!fs.existsSync(skillPath)) {
+      return res.status(404).json({ error: `Skill "${name}" not found` });
+    }
+    const content = fs.readFileSync(skillPath, 'utf8');
+    res.json({ name, content });
+  } catch (err) { serverError(res, err); }
+});
+
+skillsRouter.put('/api/skills/:name', requireAuth, requireScope('files:write', 'ssss:write'), (req, res) => {
+  try {
+    const { name } = req.params;
+    const { content } = req.body;
+    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
+      return res.status(400).json({ error: 'Invalid skill name' });
+    }
+    if (typeof content !== 'string') {
+      return res.status(400).json({ error: 'Missing or invalid `content` field.' });
+    }
+    const skillDir = path.join(SKILLS_DIR, name);
+    if (!fs.existsSync(skillDir)) {
+      fs.mkdirSync(skillDir, { recursive: true });
+    }
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    fs.writeFileSync(skillPath, content, 'utf8');
+    res.json({ success: true, message: `Skill "${name}" updated successfully` });
+  } catch (err) { serverError(res, err); }
+});
+
+skillsRouter.delete('/api/skills/:name', requireAuth, requireScope('files:write', 'ssss:write'), (req, res) => {
+  try {
+    const { name } = req.params;
+    if (name.includes('..') || name.includes('/') || name.includes('\\')) {
+      return res.status(400).json({ error: 'Invalid skill name' });
+    }
+    const skillDir = path.join(SKILLS_DIR, name);
+    if (!fs.existsSync(skillDir)) {
+      return res.status(404).json({ error: `Skill "${name}" not found` });
+    }
+    fs.rmSync(skillDir, { recursive: true, force: true });
+    res.json({ success: true, message: `Skill "${name}" deleted successfully` });
+  } catch (err) { serverError(res, err); }
+});