total-recall-brain 3.41.2 → 3.41.3

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);