@jlongo78/agent-spaces 0.10.0-beta.2 → 0.10.0-beta.4

package/.next/standalone/bin/scrub-standalone.js

@@ -22,6 +22,11 @@ const DENY_DIRS = [
   '.gemini',
   '.pi',
   'logs',
+  // Internal planning/design docs — embed maintainer-local paths and were
+  // never meant to ship to end users. Keeping them at HEAD (for collaboration)
+  // but not in the published tarball.
+  'plans',
+  'superpowers',
 ];
 
 const DENY_PATTERNS = [

package/.next/standalone/bin/spaces-dev.js

@@ -37,6 +37,11 @@ const MANAGED_NODE_MODULES = path.join(MANAGED_PACKAGES, 'node_modules');
 const isMultiuser = process.env.SPACES_MULTIUSER === '1' || savedConfig.multiuser === true;
 if (isMultiuser) process.env.SPACES_MULTIUSER = '1';
 
+// Default LAN-reachable (0.0.0.0). Management routes are loopback-only in
+// desktop mode via the requireAdmin guard; basic browsing works from anywhere.
+const localhostOnly = process.env.SPACES_LOCALHOST_ONLY === '1' || savedConfig.localhostOnly === true;
+const bindHost = localhostOnly ? '127.0.0.1' : '0.0.0.0';
+
 // ─── NODE_PATH for the optional cortex addon ─────────────────
 const nodePaths = [MANAGED_NODE_MODULES];
 const cortexPkgDir = path.join(MANAGED_PACKAGES, 'cortex', 'node_modules');
@@ -71,7 +76,7 @@ if (isMultiuser) {
 
 // Spawn Next.js dev server on an internal port
 const childEnv = { ...process.env, PORT: String(NEXT_INTERNAL_PORT) };
-const next = spawn('npx', ['next', 'dev', '--hostname', '0.0.0.0', '--port', String(NEXT_INTERNAL_PORT)], {
+const next = spawn('npx', ['next', 'dev', '--hostname', bindHost, '--port', String(NEXT_INTERNAL_PORT)], {
   cwd: path.join(__dirname, '..'),
   stdio: ['ignore', 'pipe', 'pipe'],
   env: childEnv,
@@ -99,13 +104,18 @@ next.on('exit', (code) => {
 
 // Create unified HTTP server
 const server = http.createServer((req, res) => {
+  // Inject authoritative source IP so handlers can check loopback. Strip any
+  // spoofed value first.
+  const headersOut = { ...req.headers };
+  delete headersOut['x-spaces-remote-ip'];
+  headersOut['x-spaces-remote-ip'] = req.socket?.remoteAddress || '';
   const proxyReq = http.request(
     {
       hostname: '127.0.0.1',
       port: NEXT_INTERNAL_PORT,
       path: req.url,
       method: req.method,
-      headers: req.headers,
+      headers: headersOut,
     },
     (proxyRes) => {
       res.writeHead(proxyRes.statusCode, proxyRes.headers);
@@ -169,7 +179,7 @@ server.on('upgrade', (req, socket, head) => {
   }
 });
 
-server.listen(PORT, () => {
+server.listen(PORT, bindHost, () => {
   console.log(`\n  Spaces dev server on http://localhost:${PORT}\n`);
 });
 

package/.next/standalone/bin/spaces.js

@@ -70,6 +70,7 @@ for (let i = 0; i < args.length; i++) {
   if (args[i] === '--setup') { cliFlags.setup = true; }
   else if (args[i] === '--port' && args[i + 1]) { cliFlags.port = parseInt(args[++i], 10); }
   else if (args[i] === '--multiuser') { cliFlags.multiuser = true; }
+  else if (args[i] === '--localhost-only') { cliFlags.localhostOnly = true; }
   else if (args[i] === '--base-path' && args[i + 1]) { cliFlags.basePath = args[++i]; }
   else if (args[i] === '--help' || args[i] === '-h') { cliFlags.help = true; }
 }
@@ -88,6 +89,7 @@ if (cliFlags.help) {
     spaces --setup               Interactive first-time setup wizard
     spaces --port 3457           Override port
     spaces --multiuser           Enable multiuser mode (login, admin UI)
+    spaces --localhost-only      Restrict access to 127.0.0.1 (default: LAN-reachable)
     spaces --base-path /spaces   Set base path for reverse proxy
     spaces service install       Install as OS service (systemd/launchd/Task Scheduler)
     spaces service uninstall     Remove OS service
@@ -242,11 +244,22 @@ function startServer() {
     || process.env.SPACES_MULTIUSER === '1'
     || savedConfig.multiuser === true;
 
+  // Bind to all interfaces by default so the user can reach Spaces from other
+  // devices on their LAN. Management endpoints (admin/*, network/keys, etc.)
+  // enforce loopback-only access in desktop mode via the requireAdmin guard,
+  // so LAN reach exposes the basic browsing surface but not admin operations.
+  // Operators who want a strict localhost lockdown can pass --localhost-only.
+  const localhostOnly = cliFlags.localhostOnly === true
+    || process.env.SPACES_LOCALHOST_ONLY === '1'
+    || savedConfig.localhostOnly === true;
+  const bindHost = localhostOnly ? '127.0.0.1' : '0.0.0.0';
+
   console.log('');
   console.log('  Spaces - Agent Workspace Manager');
   console.log('  =================================');
   console.log('');
   console.log(`  Mode: ${isMultiuser ? 'multiuser' : 'desktop'}`);
+  console.log(`  Bind: ${bindHost}${bindHost === '0.0.0.0' ? ' (LAN-reachable)' : ' (localhost only)'}`);
 
   const childEnv = { ...process.env };
 
@@ -461,7 +474,7 @@ function startServer() {
       env: {
         ...childEnv,
         PORT: String(NEXT_INTERNAL_PORT),
-        HOSTNAME: '0.0.0.0',
+        HOSTNAME: bindHost,
         NODE_ENV: 'production',
       },
     });
@@ -472,7 +485,7 @@ function startServer() {
       env: {
         ...childEnv,
         PORT: String(NEXT_INTERNAL_PORT),
-        HOSTNAME: '0.0.0.0',
+        HOSTNAME: bindHost,
         NODE_ENV: 'production',
       },
       shell: true,
@@ -534,13 +547,21 @@ function startServer() {
       return;
     }
 
+    // Strip any spoofed x-spaces-remote-ip from the inbound request, then
+    // inject the actual TCP peer so handlers can authoritatively check
+    // whether a request came from loopback. Handlers see this header set by
+    // us; clients cannot influence it.
+    const headersOut = { ...req.headers };
+    delete headersOut['x-spaces-remote-ip'];
+    headersOut['x-spaces-remote-ip'] = req.socket?.remoteAddress || '';
+
     const proxyReq = http.request(
       {
         hostname: '127.0.0.1',
         port: NEXT_INTERNAL_PORT,
         path: req.url,
         method: req.method,
-        headers: req.headers,
+        headers: headersOut,
       },
       (proxyRes) => {
         // Log cortex context API calls
@@ -605,7 +626,7 @@ function startServer() {
     });
   });
 
-  dualServer.listen(PORT, () => {
+  dualServer.listen(PORT, bindHost, () => {
     // Now that the port is bound, tell the inner servers they're "listening"
     // so terminal-server's mDNS and message watcher start up.
     httpServer.emit('listening');

package/.next/standalone/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@jlongo78/agent-spaces",
-  "version": "0.10.0-beta.2",
+  "version": "0.10.0-beta.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@jlongo78/agent-spaces",
-      "version": "0.10.0-beta.2",
+      "version": "0.10.0-beta.4",
       "hasInstallScript": true,
       "license": "AGPL-3.0-only",
       "dependencies": {

package/.next/standalone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jlongo78/agent-spaces",
-  "version": "0.10.0-beta.2",
+  "version": "0.10.0-beta.4",
   "description": "Agent workspace manager for Claude, Codex, Gemini, and more",
   "bin": {
     "spaces": "./bin/spaces.js",
@@ -33,7 +33,8 @@
     "dev": "node bin/spaces-dev.js",
     "build": "cross-env STANDALONE=1 next build && node -e \"const fs=require('fs');fs.cpSync('.next/static','.next/standalone/.next/static',{recursive:true});fs.cpSync('public','.next/standalone/public',{recursive:true})\" && node bin/fix-standalone-externals.js",
     "postinstall": "node bin/spaces-postinstall.js || true",
-    "prepublishOnly": "npm run build && node bin/scrub-standalone.js",
+    "prepublishOnly": "npm run build",
+    "prepack": "node bin/scrub-standalone.js",
     "setup": "node bin/spaces-setup.js",
     "setup-admin": "node bin/setup-admin.js",
     "server:build": "next build",

package/.next/standalone/src/app/(desktop)/terminal/page.tsx

@@ -1005,7 +1005,28 @@ function TerminalPageInner({ terminalToken }: { terminalToken: string }) {
             Close
           </button>
           <button
-            onClick={() => setShowAdd(true)}
+            onClick={() => {
+              // Preseed the form from the most recent pane in this workspace.
+              // Falls back to the workspace color and 'claude' when the workspace is empty.
+              const recent = [...panes].sort((a, b) => (b.created || '').localeCompare(a.created || ''))[0];
+              if (recent) {
+                setNewCwd(recent.cwd || '');
+                setNewColor(recent.color || activeWorkspace?.color || '#6366f1');
+                setNewAgentType(recent.agentType || 'claude');
+                setNewCustomCommand(recent.agentType === 'custom' ? (recent.customCommand || '') : '');
+                setNewNodeId(recent.nodeId || '');
+              } else {
+                setNewCwd('');
+                setNewColor(activeWorkspace?.color || '#6366f1');
+                setNewAgentType('claude');
+                setNewCustomCommand('');
+                setNewNodeId('');
+              }
+              setNewTitle('');
+              setNewClaudeSession('');
+              setNewAgentMode('new');
+              setShowAdd(true);
+            }}
             className="flex items-center gap-1.5 px-3 py-1.5 text-xs bg-indigo-600 text-white rounded-md hover:bg-indigo-500 transition-colors"
           >
           <Plus className="w-3.5 h-3.5" />

package/.next/standalone/src/app/api/network/discovered/route.ts

@@ -1,5 +1,5 @@
 import * as discovered from '@/lib/network/api/discovered';
 
-export async function GET() {
-  return discovered.GET();
+export async function GET(req: Request) {
+  return discovered.GET(req);
 }

package/.next/standalone/src/app/api/network/nodes/check/route.ts

@@ -1,5 +1,5 @@
 import * as nodesCheck from '@/lib/network/api/nodesCheck';
 
-export async function POST() {
-  return nodesCheck.POST();
+export async function POST(req: Request) {
+  return nodesCheck.POST(req);
 }

package/.next/standalone/src/app/api/network/nodes/route.ts

@@ -1,8 +1,8 @@
 import { NextRequest } from 'next/server';
 import * as nodes from '@/lib/network/api/nodes';
 
-export async function GET() {
-  return nodes.GET();
+export async function GET(req: NextRequest) {
+  return nodes.GET(req);
 }
 
 export async function POST(req: NextRequest) {

package/.next/standalone/src/app/api/server-config/route.ts

@@ -1,27 +1,18 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { IS_MULTIUSER } from '@/lib/flags';
+import { requireAdmin } from '@/lib/auth/guard';
 import { readServerConfig, writeServerConfig } from '@/lib/server-config';
 
 // Server-level config (port, basePath, multiuser) lives in ~/.spaces/server.json
 // and is read by the launcher at boot. This route exposes a small, safe subset
-// and lets the UI flip multiuser mode. A restart is required for changes to
-// take effect — see the "Restart required" banner on the settings page.
-
-// In multiuser mode, this route is only reachable by an authenticated admin —
-// middleware.ts enforces the session cookie + admin role for non-public paths.
-// In desktop mode, middleware lets everything through; the app is assumed to
-// be bound to localhost for a single user.
-function requireAdminInMultiuser(req: NextRequest): NextResponse | null {
-  if (!IS_MULTIUSER) return null;
-  const role = req.headers.get('x-auth-role');
-  if (role !== 'admin') {
-    return NextResponse.json({ error: 'Admin required' }, { status: 403 });
-  }
-  return null;
-}
+// and lets the local user flip multiuser mode. A restart is required for the
+// change to take effect — see the "Restart required" banner in Settings.
+//
+// Authorization: requireAdmin() in multiuser mode requires a validated admin
+// session; in desktop mode it requires the request to come from loopback (so a
+// LAN attacker cannot flip the victim into multiuser mode and seed a backdoor).
 
 export async function GET(req: NextRequest) {
-  const denied = requireAdminInMultiuser(req);
+  const denied = requireAdmin(req);
   if (denied) return denied;
   const { port, basePath, multiuser } = readServerConfig();
   return NextResponse.json({
@@ -32,7 +23,7 @@ export async function GET(req: NextRequest) {
 }
 
 export async function PATCH(req: NextRequest) {
-  const denied = requireAdminInMultiuser(req);
+  const denied = requireAdmin(req);
   if (denied) return denied;
   const body = await req.json().catch(() => ({}));
   const updates: Record<string, unknown> = {};

package/.next/standalone/src/lib/admin/api/analytics.ts

@@ -6,14 +6,7 @@ import {
   getDailySessionMinutes,
   getUserSessionSummary,
 } from '../db';
-
-function requireAdmin(request: Request): Response | null {
-  const role = request.headers.get('x-auth-role') || 'user';
-  if (role !== 'admin') {
-    return Response.json({ error: 'Forbidden' }, { status: 403 });
-  }
-  return null;
-}
+import { requireAdmin } from '@/lib/auth/guard';
 
 export async function GET(request: Request) {
   const denied = requireAdmin(request);

package/.next/standalone/src/lib/admin/api/users.ts

@@ -1,13 +1,6 @@
 import { execFileSync } from 'child_process';
 import { listUsers, createUser } from '../db';
-
-function requireAdmin(request: Request): Response | null {
-  const role = request.headers.get('x-auth-role') || 'user';
-  if (role !== 'admin') {
-    return Response.json({ error: 'Forbidden' }, { status: 403 });
-  }
-  return null;
-}
+import { requireAdmin } from '@/lib/auth/guard';
 
 export async function GET(request: Request) {
   const denied = requireAdmin(request);

package/.next/standalone/src/lib/admin/api/usersById.ts

@@ -1,18 +1,11 @@
 import { execFileSync } from 'child_process';
 import { getUserById, updateUser, deleteUser } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 
 function getAuthUser(request: Request): string {
   return request.headers.get('x-auth-user') || require('os').userInfo().username;
 }
 
-function requireAdmin(request: Request): Response | null {
-  const role = request.headers.get('x-auth-role') || 'user';
-  if (role !== 'admin') {
-    return Response.json({ error: 'Forbidden' }, { status: 403 });
-  }
-  return null;
-}
-
 function formatUser(u: NonNullable<ReturnType<typeof getUserById>>) {
   return {
     id: u.id,

package/.next/standalone/src/lib/auth/guard.ts

@@ -0,0 +1,46 @@
+import { NextResponse } from 'next/server';
+import { IS_MULTIUSER } from '@/lib/flags';
+
+const LOOPBACK_PREFIXES = ['127.', '::1', '::ffff:127.'];
+
+/**
+ * The wrapping HTTP server (bin/spaces.js / bin/spaces-dev.js) injects
+ * x-spaces-remote-ip from the actual TCP peer. Middleware strips any client
+ * value before forwarding, so this is always either the real source or empty.
+ */
+function isLoopback(req: Request): boolean {
+  const ip = req.headers.get('x-spaces-remote-ip') || '';
+  return LOOPBACK_PREFIXES.some(p => ip.startsWith(p));
+}
+
+/**
+ * Require admin authority on a request. The single canonical guard for
+ * management endpoints (admin/*, server-config PATCH, network/{keys,nodes,
+ * proxy,identity-PUT,discovered}).
+ *
+ * - Multiuser mode: trusts the `x-auth-role` header. Middleware sets this
+ *   only after validating a session cookie, and strips any incoming value
+ *   before forwarding — so an attacker cannot spoof it.
+ * - Desktop mode: there is no login, so we authorize based on the actual TCP
+ *   source IP. Loopback (127.0.0.0/8, ::1) is treated as the local admin;
+ *   anything else is refused. This keeps the basic browsing routes
+ *   LAN-reachable while keeping management operations off the LAN.
+ *
+ * Returns null when the request should proceed, or a Response when denied.
+ */
+export function requireAdmin(req: Request): Response | null {
+  if (IS_MULTIUSER) {
+    const role = req.headers.get('x-auth-role');
+    if (role !== 'admin') {
+      return NextResponse.json({ error: 'Admin required' }, { status: 403 });
+    }
+    return null;
+  }
+  if (!isLoopback(req)) {
+    return NextResponse.json(
+      { error: 'Management endpoints are restricted to localhost in desktop mode. Run in multiuser mode (SPACES_MULTIUSER=1) for remote admin.' },
+      { status: 403 }
+    );
+  }
+  return null;
+}

package/.next/standalone/src/lib/auth/index.ts

@@ -1,4 +1,5 @@
 export { getAuthUser, withUser, getAuthRole, getCurrentUser } from './context';
+export { requireAdmin } from './guard';
 export {
   issueSessionToken,
   verifySessionToken,

package/.next/standalone/src/lib/db/queries.ts

@@ -625,7 +625,17 @@ export function updatePane(id: string, data: {
   if (data.winHeight !== undefined) { sets.push('win_height = ?'); vals.push(data.winHeight); }
   if ((data as any).nodeId !== undefined) { sets.push('node_id = ?'); vals.push((data as any).nodeId); }
   if (data.isCollaborating !== undefined) { sets.push('is_collaborating = ?'); vals.push(data.isCollaborating ? 1 : 0); }
-  if (data.diffBaselineSha !== undefined) { sets.push('diff_baseline_sha = ?'); vals.push(data.diffBaselineSha); }
+  if (data.diffBaselineSha !== undefined) {
+    // Whitelist git SHA shape — diffBaselineSha is later passed as a positional
+    // argument to `git diff <sha> HEAD`; without this guard a value like
+    // "--output=/path/to/file" would be interpreted as a git option and
+    // git would write the diff content to an attacker-chosen path.
+    const sha = data.diffBaselineSha;
+    if (sha !== null && !/^[0-9a-f]{7,40}$/.test(sha)) {
+      throw new Error('Invalid diffBaselineSha (must be a git SHA hex)');
+    }
+    sets.push('diff_baseline_sha = ?'); vals.push(sha);
+  }
   if (data.customModelId !== undefined) { sets.push('custom_model_id = ?'); vals.push(data.customModelId); }
 
   if (sets.length === 0) return;

package/.next/standalone/src/lib/network/api/discovered.ts

@@ -1,7 +1,10 @@
 import { NextResponse } from 'next/server';
 import { getDiscoveredNodes } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 
-export async function GET() {
+export async function GET(request: Request) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const nodes = getDiscoveredNodes();
   return NextResponse.json(nodes);
 }

package/.next/standalone/src/lib/network/api/identity.ts

@@ -1,5 +1,9 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getNodeIdentity, setNodeName } from '../identity';
+import { requireAdmin } from '@/lib/auth/guard';
+
+// GET is intentionally public (used by remote nodes during handshake).
+// PUT is admin-only — sets the local node's display name in network.db.
 
 export async function GET() {
   const identity = getNodeIdentity();
@@ -7,6 +11,8 @@ export async function GET() {
 }
 
 export async function PUT(request: NextRequest) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { name } = await request.json() as any;
   if (!name || typeof name !== 'string' || !name.trim()) {
     return NextResponse.json({ error: 'Name is required' }, { status: 400 });

package/.next/standalone/src/lib/network/api/keys.ts

@@ -1,14 +1,20 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { listApiKeys, createApiKey } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 import os from 'os';
 
 export async function GET(request: NextRequest) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const username = request.headers.get('x-auth-user') || os.userInfo().username;
   const keys = listApiKeys(username);
   return NextResponse.json(keys);
 }
 
 export async function POST(request: NextRequest) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
+
   const { name, permissions } = await request.json() as any;
 
   if (!name || typeof name !== 'string' || !name.trim()) {

package/.next/standalone/src/lib/network/api/keysById.ts

@@ -1,8 +1,11 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { revokeApiKey, getNetworkDb } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 import os from 'os';
 
 export async function DELETE(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { id } = await params;
   const username = request.headers.get('x-auth-user') || os.userInfo().username;
 

package/.next/standalone/src/lib/network/api/nodes.ts

@@ -1,20 +1,65 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { listNodes, addNode, updateNodeStatus, getNode } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 import type { HandshakeResponse } from '../../../types/network';
 
-export async function GET() {
+// Reject URLs that point at private/loopback networks. Adding a node fetches
+// the URL with the supplied bearer token; without this guard a caller could
+// probe internal services or cloud metadata via SSRF and read the response
+// body in the error path. See vuln 5 in 2026-04-26 audit.
+function rejectPrivateUrl(rawUrl: string): string | null {
+  let parsed: URL;
+  try { parsed = new URL(rawUrl); } catch { return 'URL is not parseable'; }
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return 'URL must be http or https';
+  }
+  const host = parsed.hostname.toLowerCase();
+  // Block by hostname literal first (cheap, catches the obvious cases)
+  const blockedHosts = ['localhost', '0.0.0.0'];
+  if (blockedHosts.includes(host)) return 'Loopback hostnames are not allowed';
+  // Block IPv4 in private/loopback/link-local ranges
+  const v4 = host.match(/^(\d+)\.(\d+)\.(\d+)\.(\d+)$/);
+  if (v4) {
+    const [a, b] = [parseInt(v4[1], 10), parseInt(v4[2], 10)];
+    if (a === 127) return 'Loopback IPs are not allowed';
+    if (a === 10) return 'Private IPs are not allowed';
+    if (a === 192 && b === 168) return 'Private IPs are not allowed';
+    if (a === 172 && b >= 16 && b <= 31) return 'Private IPs are not allowed';
+    if (a === 169 && b === 254) return 'Link-local IPs are not allowed';
+    if (a === 0) return 'Reserved IPs are not allowed';
+  }
+  // Block IPv6 loopback / link-local / unique-local
+  if (host.startsWith('[::1') || host === '::1') return 'Loopback IPs are not allowed';
+  if (host.startsWith('[fe80') || host.startsWith('fe80:')) return 'Link-local IPs are not allowed';
+  if (host.startsWith('[fc') || host.startsWith('[fd') || host.startsWith('fc') || host.startsWith('fd')) {
+    return 'Private IPs are not allowed';
+  }
+  return null;
+}
+
+export async function GET(request: NextRequest) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const nodes = listNodes();
   return NextResponse.json(nodes);
 }
 
 export async function POST(request: NextRequest) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
+
   const { url, apiKey, name } = await request.json() as any;
 
   if (!url || !apiKey) {
     return NextResponse.json({ error: 'URL and API key are required' }, { status: 400 });
   }
+  if (typeof url !== 'string') {
+    return NextResponse.json({ error: 'URL must be a string' }, { status: 400 });
+  }
 
   const baseUrl = url.replace(/\/+$/, '');
+  const reject = rejectPrivateUrl(baseUrl);
+  if (reject) return NextResponse.json({ error: reject }, { status: 400 });
 
   let handshake: HandshakeResponse;
   try {
@@ -25,9 +70,10 @@ export async function POST(request: NextRequest) {
     });
 
     if (!res.ok) {
-      const body = await res.text();
+      // Don't echo the upstream response body — it may contain sensitive
+      // content (admin pages, cloud metadata) that the attacker probed for.
       return NextResponse.json(
-        { error: `Handshake failed (${res.status}): ${body}` },
+        { error: `Handshake failed with status ${res.status}` },
         { status: 400 }
       );
     }

package/.next/standalone/src/lib/network/api/nodesById.ts

@@ -1,7 +1,10 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getNode, updateNode, removeNode } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 
 export async function PUT(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { id } = await params;
   const data: any = await request.json();
 
@@ -16,6 +19,8 @@ export async function PUT(request: NextRequest, { params }: { params: Promise<{
 }
 
 export async function DELETE(request: NextRequest, { params }: { params: Promise<{ id: string }> }) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { id } = await params;
 
   const node = getNode(id);

package/.next/standalone/src/lib/network/api/nodesCheck.ts

@@ -1,7 +1,10 @@
 import { NextResponse } from 'next/server';
 import { listNodes, getNodeApiKey, updateNodeStatus } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 
-export async function POST() {
+export async function POST(request: Request) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const nodes = listNodes();
   const results: { nodeId: string; status: string; error?: string }[] = [];
 

package/.next/standalone/src/lib/network/api/proxy.ts

@@ -1,10 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { getNode, getNodeApiKey } from '../db';
+import { requireAdmin } from '@/lib/auth/guard';
 
 export async function GET(
   request: NextRequest,
   { params }: { params: Promise<{ nodeId: string; path: string[] }> }
 ) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { nodeId, path: pathSegments } = await params;
 
   const node = getNode(nodeId);
@@ -41,6 +44,8 @@ export async function POST(
   request: NextRequest,
   { params }: { params: Promise<{ nodeId: string; path: string[] }> }
 ) {
+  const denied = requireAdmin(request);
+  if (denied) return denied;
   const { nodeId, path: pathSegments } = await params;
 
   const node = getNode(nodeId);