total-recall-brain 3.41.1 → 3.41.3

package/src/core/skills-registry.mjs

@@ -456,6 +456,11 @@ export function deploySkill(brainDir, skillIdOrPath, opts = {}) {
   if (layered && fs.existsSync(destDir) && fs.lstatSync(destDir).isSymbolicLink()) {
     throw new Error(`Refusing layered deploy into symlink: ${destDir}`);
   }
+  if (opts.dryRun) return { success: true, dryRun: true, skillId: resolved.id, destDir,
+    sourcePath: resolved.sourcePath, layered, existed, routeCore: Boolean(opts.routeCore), actions: [
+      { op: 'replace-managed', from: layered && existed ? path.join(resolved.sourcePath, 'core') : resolved.sourcePath, to: layered && existed ? path.join(destDir, 'core') : destDir },
+      ...(opts.routeCore && layered ? [{ op: 'route-core', path: path.join(destDir, 'SKILL.md') }] : []),
+    ] };
   const replacement = layered && existed
     ? replaceSkillDir(path.join(resolved.sourcePath, 'core'), path.join(destDir, 'core'), {
         requiredFile: null,
@@ -463,6 +468,14 @@ export function deploySkill(brainDir, skillIdOrPath, opts = {}) {
       })
     : replaceSkillDir(resolved.sourcePath, destDir, { managedFiles: priorInstall?.managed_files || [] });
 
+  if (opts.routeCore && layered) {
+    const wrapper = path.join(destDir, 'SKILL.md');
+    const current = fs.readFileSync(wrapper, 'utf8');
+    const marker = '<!-- total-recall:managed-core-route:v1 -->';
+    if (!current.includes(marker)) fs.writeFileSync(wrapper, current.replace(/\s*$/, '') +
+      `\n\n${marker}\nRead the [maintained portable core](core/SKILL.md) for current protocol contracts; preserve repository-specific instructions above.\n`);
+  }
+
   let adaptResult = { adapted: false };
   if (opts.adapt && (!layered || !existed)) {
     const openwikiDir =
@@ -536,7 +549,7 @@ function installDetail(entry, inst) {
   const liveHash = exists ? hashSkillContent(inst.path) : null;
   const liveCoreHash = layered && exists ? hashSkillLayer(inst.path, 'core') : null;
   const liveRepoHash = layered && exists ? hashSkillLayer(inst.path, 'repo') : null;
-  const drift = layered
+  const drift = !exists ? true : layered
     ? liveCoreHash !== (entry?.core_hash || inst.core_hash)
     : legacyUnderLayered
       ? false
@@ -548,7 +561,9 @@ function installDetail(entry, inst) {
   return {
     ...inst,
     exists,
+    required: !inst.obsolete,
     live_hash: liveHash,
+    verification: !exists ? 'missing' : legacyUnderLayered ? 'not_adopted' : drift ? 'drifted' : 'verified',
     ...(layered ? {
       core_hash: liveCoreHash,
       repo_hash: liveRepoHash,
@@ -576,7 +591,7 @@ export function skillStatus(brainDir, skillId) {
     } catch (err) {
       // One unreadable install (a symlinked layer, a moved repo) must not hide
       // the status of every other install.
-      return { ...inst, exists: fs.existsSync(inst.path), error: err.message, drift: false };
+      return { ...inst, exists: fs.existsSync(inst.path), error: err.message, drift: true, verification: 'error' };
     }
   });
 
@@ -593,7 +608,11 @@ export function skillStatus(brainDir, skillId) {
     localPath,
     installs: installDetails,
     install_count: installDetails.length,
-    any_drift: installDetails.some((i) => i.drift),
+    any_drift: installDetails.some((i) => !i.obsolete && i.drift),
+    verified: Boolean(entry && localPath) && installDetails.every((i) => i.obsolete || (i.verification === 'verified' && (!i.contract || i.contract.ok))),
+    missing_count: installDetails.filter((i) => !i.obsolete && !i.exists).length,
+    obsolete_count: installDetails.filter((i) => i.obsolete).length,
+    error_count: installDetails.filter((i) => i.error).length,
     any_contract_failure: installDetails.some((i) => i.contract && !i.contract.ok),
   };
 }
@@ -1269,6 +1288,17 @@ export function syncSkillTwoWay(brainDir, skillId, opts = {}) {
   }
 
   const { entry, locations } = collectSkillLocations(brainDir, skillId);
+  const missingInstalls = loadRegistry(brainDir).installs.filter((inst) =>
+    inst.skill_id === skillId && !inst.obsolete && !fs.existsSync(path.join(inst.path, 'SKILL.md')),
+  );
+  if (missingInstalls.length) {
+    return {
+      skillId, in_sync: false, dryRun,
+      error: 'Recorded skill destinations are missing; reconcile existing repositories and deploy explicitly before synchronization',
+      missing: missingInstalls.map((inst) => ({ path: inst.path, repo: inst.repo, repository_exists: Boolean(inst.repo && fs.existsSync(inst.repo)) })),
+      locations: locations.length, actions: [],
+    };
+  }
   if (!locations.length) {
     return { skillId, skipped: true, reason: 'no live copies found' };
   }

package/src/server/auth.mjs

@@ -6,4 +6,44 @@ import { findValidKeyByToken, keyHasAnyScope, recordKeyUsage, recordKeyOutcome }
 import { logger } from '../core/logger.mjs';
 const owner = await loadPluginModule('auth', 'server-auth');
 export const BCRYPT_COST = owner.BCRYPT_COST;
-export const { loadSecurityConfig, apiRateLimiter, authRateLimiter, sandboxRateLimiter, ingestRateLimiter, isLoopbackIp, isMeshIp, isLocalRequest, requireHttps, requireAuthOrLocal, corsOptions, requireAuth, requireScope, requireSandboxEnabled, sessionCookieOptions, loginHandler, changePasswordHandler, mintStepUpToken, verifyStepUpToken, verifyDashboardPassword, logoutHandler, signSessionToken, dashboardAuthState } = owner.createServerAuth({ brainDir, authBrainDir: process.env.TR_SECRETS_BRAIN || brainDir, nodeEnv, watchdog, findValidKeyByToken, keyHasAnyScope, recordKeyUsage, recordKeyOutcome, logger });
+const base = owner.createServerAuth({ brainDir, authBrainDir: process.env.TR_SECRETS_BRAIN || brainDir, nodeEnv, watchdog, findValidKeyByToken, keyHasAnyScope, recordKeyUsage, recordKeyOutcome, logger });
+export const { loadSecurityConfig, apiRateLimiter, authRateLimiter, sandboxRateLimiter, ingestRateLimiter, isLoopbackIp, isMeshIp, isLocalRequest, requireHttps, requireAuthOrLocal, corsOptions, requireScope, requireSandboxEnabled, sessionCookieOptions, loginHandler, changePasswordHandler, mintStepUpToken, verifyStepUpToken, verifyDashboardPassword, logoutHandler, signSessionToken, dashboardAuthState } = base;
+
+const hostName = (value) => String(value || '').replace(/^https?:\/\//, '').replace(/[/?#].*$/, '').replace(/:\d+$/, '').replace(/^\[(.*)\]$/, '$1');
+
+let alwaysRequired = false;
+
+/** Headless hosts (the memory-only runtime) never offer the open-local mode. */
+export function enforceLogin() {
+  alwaysRequired = true;
+}
+
+/**
+ * Dashboard login is optional for a local install. It is required when
+ * `dashboard.require_login` is true, or, when unset, once a dashboard password
+ * exists. When not required, only a genuinely local browser or CLI is let in:
+ * loopback socket, loopback Host header and no foreign Origin (which blocks DNS
+ * rebinding and cross-site requests). Bearer tokens and every other client
+ * (mesh, tunnel, remote) still authenticate normally.
+ */
+export function loginRequired() {
+  if (alwaysRequired) return true;
+  const configured = loadSecurityConfig().dashboard?.require_login;
+  return typeof configured === 'boolean' ? configured : dashboardAuthState().configured;
+}
+
+function isOpenLocalRequest(req) {
+  if (req.headers.authorization) return false;
+  if (!isLocalRequest(req)) return false;
+  if (!isLoopbackIp(hostName(req.headers.host))) return false;
+  const origin = req.headers.origin;
+  return !origin || isLoopbackIp(hostName(origin));
+}
+
+export function requireAuth(req, res, next) {
+  if (!loginRequired() && isOpenLocalRequest(req)) {
+    req.auth = { type: 'dashboard_session', local: true };
+    return next();
+  }
+  return base.requireAuth(req, res, next);
+}

package/src/server/memory-app.mjs

@@ -4,7 +4,7 @@ import cors from 'cors';
 import cookieParser from 'cookie-parser';
 import fs from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { requireHttps, corsOptions, apiRateLimiter, requireAuthOrLocal } from './auth.mjs';
+import { requireHttps, corsOptions, apiRateLimiter, requireAuthOrLocal, enforceLogin } from './auth.mjs';
 import { memoryRouter } from './routes/memory.mjs';
 import { authRouter } from './routes/auth.mjs';
 import { keysRouter } from './routes/keys.mjs';
@@ -17,6 +17,7 @@ import { getNodes } from '../core/vault-cache.mjs';
 const { version } = JSON.parse(fs.readFileSync(fileURLToPath(new URL('../../package.json', import.meta.url)), 'utf8'));
 
 export function createMemoryApp() {
+  enforceLogin();
   const app = express();
   app.disable('x-powered-by');
   app.set('trust proxy', 'loopback');

package/src/server/routes/auth.mjs

@@ -1,7 +1,31 @@
 /** Required auth plugin adapter for dashboard authentication routes. */
+import express from 'express';
 import * as auth from '../auth.mjs';
 import { logger } from '../../core/logger.mjs';
 import { BRAIN_DIR } from './_shared.mjs';
 import { loadPluginModule } from '../../core/plugin-runtime.mjs';
 const { createAuthRouter } = await loadPluginModule('auth', 'auth-router');
-export const authRouter = createAuthRouter({ auth, logger, BRAIN_DIR });
+const pluginRouter = createAuthRouter({ auth, logger, BRAIN_DIR });
+
+/**
+ * Total Recall has no Google sign-in: the plugin serves it for apps that do,
+ * so this router refuses those routes and drops Google from provider discovery.
+ */
+export const authRouter = express.Router();
+authRouter.use('/auth/google', (_req, res) => res.status(404).json({ error: 'Google sign-in is not available in Total Recall' }));
+authRouter.use('/auth/providers', (req, res, next) => {
+  if (req.method !== 'GET') return next();
+  const json = res.json.bind(res);
+  res.json = (body) => {
+    if (body && typeof body === 'object') delete body.google;
+    return json(body);
+  };
+  next();
+});
+authRouter.use('/auth/status', (req, res, next) => {
+  if (req.method !== 'GET') return next();
+  const json = res.json.bind(res);
+  res.json = (body) => json({ ...body, login_required: auth.loginRequired() });
+  next();
+});
+authRouter.use(pluginRouter);

package/src/server/routes/plugins.mjs

@@ -307,15 +307,28 @@ router.patch("/api/plugins/:id/card-face", requireAuth, requireScope("config:wri
 /**
  * POST /api/plugins/:id/run  body: { subcommand?, args? }
  * Runs the plugin's CLI handler in a child process. Executing plugin code is a
- * write-level action.
+ * write-level action unless the installed manifest explicitly declares the
+ * exact operation read-only. Alternate execution and credential input remain
+ * write-level regardless of that declaration.
  */
-router.post("/api/plugins/:id/run", requireAuth, requireScope("config:write"), async (req, res) => {
+router.post("/api/plugins/:id/run", requireAuth, (req, res, next) => {
+  const { subcommand, args = [], stdin, execution } = req.body || {};
+  try {
+    const plugin = getPluginById(req.params.id, projectRoot());
+    const operation = plugin?.valid && plugin.manifest?.cli?.subcommands?.find(item => item.name === subcommand);
+    res.locals.executionPlugin = plugin;
+    const read = typeof subcommand === 'string' && Array.isArray(args) && args.every(arg => typeof arg === 'string') &&
+      operation?.effect === 'read' && stdin === undefined && !execution &&
+      !operation.args?.some(arg => arg.secret);
+    return requireScope(read ? 'config:read' : 'config:write')(req, res, next);
+  } catch (error) { badRequest(res, error.message); }
+}, async (req, res) => {
   try {
     const { subcommand = "", args = [], stdin, execution } = req.body || {};
     if (typeof subcommand !== "string" || !Array.isArray(args) || args.some((a) => typeof a !== "string")) {
       return badRequest(res, "subcommand must be a string and args an array of strings");
     }
-    const plugin = getPluginById(req.params.id, projectRoot());
+    const plugin = res.locals.executionPlugin;
     if (!plugin) return res.status(404).json({ success: false, error: `Plugin ${req.params.id} not found` });
     if (!plugin.valid) return badRequest(res, `Plugin ${plugin.id} has an invalid manifest: ${plugin.errors.join("; ")}`);
     if (!plugin.manifest?.cli?.handler) return badRequest(res, `Plugin ${plugin.id} does not declare a CLI handler`);
@@ -330,7 +343,7 @@ router.post("/api/plugins/:id/run", requireAuth, requireScope("config:write"), a
       return res.json({ success: result.ok, pluginId: plugin.id, ...result });
     }
 
-    const result = await runPluginCommand(plugin, { subcommand, args, ...(stdin !== undefined ? { stdinText: stdin } : {}), cwd: projectRoot(), secretsBrainDir: process.env.TR_SECRETS_BRAIN || globalBrainDir || BRAIN_DIR });
+    const result = await runPluginCommand(plugin, { subcommand, args, ...(stdin !== undefined ? { stdinText: stdin } : {}), cwd: projectRoot(), secretsBrainDir: process.env.TR_SECRETS_BRAIN || globalBrainDir || BRAIN_DIR, maxOutputBytes: 4 * 1024 * 1024 });
     res.json({ success: result.ok, pluginId: plugin.id, ...result });
   } catch (err) {
     badRequest(res, err.message);