neural-loom 0.2.70 → 0.3.0

package/bin/cli.js

@@ -140,10 +140,20 @@ process.chdir(packageRoot);
 // Next.js provides a cli entry point in next/dist/bin/next
 const nextBin = require.resolve('next/dist/bin/next');
 
+// Bind to loopback by default so the dashboard (which exposes shell, filesystem
+// and DB access) is not reachable from the local network. Opt in with
+// NEURAL_LOOM_ALLOW_LAN=1, or override the interface with NEURAL_LOOM_HOST.
+const allowLan = ['1', 'true', 'yes'].includes((process.env.NEURAL_LOOM_ALLOW_LAN || '').toLowerCase());
+const bindHost = process.env.NEURAL_LOOM_HOST || (allowLan ? '0.0.0.0' : '127.0.0.1');
+const port = process.env.PORT || '9600';
+
 console.log("🚀 Starting NeuralLoom AI Orchestrator dashboard...");
-console.log(`🔗 Open http://localhost:${process.env.PORT || 9600} in your browser to begin.`);
+console.log(`🔗 Open http://localhost:${port} in your browser to begin.`);
+if (allowLan || process.env.NEURAL_LOOM_HOST) {
+  console.log(`🌐 Binding to ${bindHost} (network access enabled).`);
+}
 
-const nextProcess = spawn(process.execPath, [nextBin, 'start', '-p', process.env.PORT || '9600'], {
+const nextProcess = spawn(process.execPath, [nextBin, 'start', '-p', port, '-H', bindHost], {
   stdio: 'inherit',
   env: {
     ...process.env,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neural-loom",
-  "version": "0.2.70",
+  "version": "0.3.0",
   "bin": {
     "neural-loom": "./bin/cli.js"
   },
@@ -14,10 +14,12 @@
     "README.md"
   ],
   "scripts": {
-    "dev": "next dev",
+    "dev": "next dev -H 127.0.0.1",
     "build": "next build",
-    "start": "next start",
-    "lint": "eslint"
+    "start": "next start -H 127.0.0.1",
+    "lint": "eslint .",
+    "test": "node --test --experimental-strip-types \"test/**/*.test.ts\"",
+    "prepublishOnly": "next build"
   },
   "dependencies": {
     "@monaco-editor/react": "^4.7.0",
@@ -25,6 +27,7 @@
     "mssql": "^12.5.5",
     "next": "16.2.6",
     "node-pty": "^1.1.0",
+    "pidusage": "^3.0.2",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "ws": "^8.21.0",
@@ -33,11 +36,11 @@
   },
   "devDependencies": {
     "@types/node": "^20",
-    "@types/react": "^19",
+    "@types/react": "19.2.17",
     "@types/react-dom": "^19",
     "@types/ws": "^8.18.1",
     "eslint": "^9",
     "eslint-config-next": "16.2.6",
-    "typescript": "^5"
+    "typescript": "5.9.3"
   }
 }

package/src/app/api/files/route.ts

@@ -2,6 +2,24 @@ import { NextResponse } from "next/server";
 import fs from "fs";
 import path from "path";
 import os from "os";
+import { getConfigDir } from "@/lib/config";
+
+// NeuralLoom's runtime/secret store (.ai/neural-loom, .claude/, the resolved
+// config dir) holds credentials, SSH keys and process state. The generic file
+// API must never read or mutate it, regardless of caller.
+function isProtectedPath(targetPath: string): boolean {
+  const norm = path.resolve(targetPath).replace(/\\/g, "/").toLowerCase();
+  const segments = norm.split("/");
+  if (segments.includes(".ai") || segments.includes(".claude")) return true;
+  const cfg = getConfigDir().replace(/\\/g, "/").toLowerCase();
+  return norm === cfg || norm.startsWith(cfg + "/");
+}
+
+const protectedResponse = () =>
+  NextResponse.json(
+    { error: "Access to NeuralLoom's runtime/config directory is not permitted." },
+    { status: 403 }
+  );
 
 // Helper to recursively generate a tree nodes list for UI representation
 interface TreeNode {
@@ -229,6 +247,9 @@ export async function GET(request: Request) {
       }
 
       const filePath = filePathRaw.replace(/\\/g, "/");
+      if (isProtectedPath(filePath)) {
+        return protectedResponse();
+      }
       if (!fs.existsSync(filePath)) {
         return NextResponse.json({ error: "File does not exist" }, { status: 404 });
       }
@@ -252,6 +273,15 @@ export async function POST(request: Request) {
     const oldPath = rawOldPath ? rawOldPath.replace(/\\/g, "/") : undefined;
     const newPath = rawNewPath ? rawNewPath.replace(/\\/g, "/") : undefined;
 
+    // Refuse any mutation that touches the runtime/secret store.
+    if (
+      (filePath && isProtectedPath(filePath)) ||
+      (oldPath && isProtectedPath(oldPath)) ||
+      (newPath && isProtectedPath(newPath))
+    ) {
+      return protectedResponse();
+    }
+
     if (action === "write") {
       if (!filePath || content === undefined) {
         return NextResponse.json({ error: "Missing 'path' or 'content' in body" }, { status: 400 });

package/src/app/api/git/route.ts

@@ -1,10 +1,22 @@
 import { NextResponse } from "next/server";
 import { promisify } from "util";
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import fs from "fs";
 import path from "path";
+import { isValidBranchName } from "@/lib/gitSafe";
 
-const execPromise = promisify(exec);
+const execFilePromise = promisify(execFile);
+
+// Run git without a shell. Arguments are passed as an array, so values like file
+// names, branch names and commit messages cannot break out into shell commands.
+async function git(args: string[], cwd: string): Promise<{ stdout: string; stderr: string }> {
+  const { stdout, stderr } = await execFilePromise("git", args, {
+    cwd,
+    maxBuffer: 1024 * 1024 * 20,
+    windowsHide: true,
+  });
+  return { stdout: stdout.toString(), stderr: stderr.toString() };
+}
 
 export async function GET(request: Request) {
   try {
@@ -17,13 +29,13 @@ export async function GET(request: Request) {
 
     // Check if it's a git repo
     try {
-      await execPromise("git rev-parse --is-inside-work-tree", { cwd: targetRoot });
+      await git(["rev-parse", "--is-inside-work-tree"], targetRoot);
     } catch {
       return NextResponse.json({ success: true, isGit: false, files: [] });
     }
 
     if (action === "status") {
-      const { stdout } = await execPromise("git status --porcelain", { cwd: targetRoot });
+      const { stdout } = await git(["status", "--porcelain"], targetRoot);
       const lines = stdout.split(/\r?\n/).filter(Boolean);
       const files = lines.map(line => {
         // porcelain format: XY path or XY "path"
@@ -49,7 +61,7 @@ export async function GET(request: Request) {
       // Get branch name
       let branch = "";
       try {
-        const { stdout: branchOut } = await execPromise("git rev-parse --abbrev-ref HEAD", { cwd: targetRoot });
+        const { stdout: branchOut } = await git(["rev-parse", "--abbrev-ref", "HEAD"], targetRoot);
         branch = branchOut.trim();
       } catch {}
 
@@ -57,7 +69,7 @@ export async function GET(request: Request) {
       let ahead = 0;
       let behind = 0;
       try {
-        const { stdout: syncOut } = await execPromise("git rev-list --left-right --count HEAD...@{u}", { cwd: targetRoot });
+        const { stdout: syncOut } = await git(["rev-list", "--left-right", "--count", "HEAD...@{u}"], targetRoot);
         const parts = syncOut.trim().split(/\s+/);
         if (parts.length === 2) {
           ahead = parseInt(parts[0], 10) || 0;
@@ -79,7 +91,7 @@ export async function GET(request: Request) {
       }
 
       // Check status to see if it is untracked
-      const { stdout: statusOut } = await execPromise("git status --porcelain -- " + JSON.stringify(file), { cwd: targetRoot });
+      const { stdout: statusOut } = await git(["status", "--porcelain", "--", file], targetRoot);
       const isUntracked = statusOut.startsWith("??");
 
       if (isUntracked) {
@@ -88,7 +100,7 @@ export async function GET(request: Request) {
         return NextResponse.json({ success: true, diff: diffLines });
       } else {
         try {
-          const { stdout: diffOut } = await execPromise(`git diff --no-color -- ${JSON.stringify(file)}`, { cwd: targetRoot });
+          const { stdout: diffOut } = await git(["diff", "--no-color", "--", file], targetRoot);
           return NextResponse.json({ success: true, diff: diffOut });
         } catch {
           return NextResponse.json({ success: true, diff: `Binary file or diff unavailable.` });
@@ -97,7 +109,7 @@ export async function GET(request: Request) {
     }
 
     if (action === "branches") {
-      const { stdout } = await execPromise("git branch --format=\"%(refname:short)|%(HEAD)\"", { cwd: targetRoot });
+      const { stdout } = await git(["branch", "--format=%(refname:short)|%(HEAD)"], targetRoot);
       const branches = stdout.split(/\r?\n/).filter(Boolean).map(line => {
         const [name, active] = line.split("|");
         return {
@@ -110,7 +122,10 @@ export async function GET(request: Request) {
 
     if (action === "log") {
       try {
-        const { stdout } = await execPromise("git log --graph --abbrev-commit --decorate --format=format:\"%h||%p||%s||%an||%ar\" --all -n 100", { cwd: targetRoot });
+        const { stdout } = await git(
+          ["log", "--graph", "--abbrev-commit", "--decorate", "--format=format:%h||%p||%s||%an||%ar", "--all", "-n", "100"],
+          targetRoot
+        );
         const lines = stdout.split(/\r?\n/);
         const logItems = lines.map(line => {
           const parts = line.split("||");
@@ -119,7 +134,7 @@ export async function GET(request: Request) {
             const hashMatch = firstPart.match(/([0-9a-f]{7,40})$/);
             const hash = hashMatch ? hashMatch[1] : "";
             const graph = firstPart.substring(0, firstPart.length - hash.length);
-            
+
             return {
               isCommit: true,
               graph,
@@ -142,7 +157,7 @@ export async function GET(request: Request) {
           }
         });
         return NextResponse.json({ success: true, log: logItems });
-      } catch (err) {
+      } catch {
         return NextResponse.json({ success: true, log: [] });
       }
     }
@@ -163,25 +178,25 @@ export async function POST(request: Request) {
 
     // Check if it's a git repo
     try {
-      await execPromise("git rev-parse --is-inside-work-tree", { cwd: targetRoot });
+      await git(["rev-parse", "--is-inside-work-tree"], targetRoot);
     } catch {
       return NextResponse.json({ error: "Not a git repository" }, { status: 400 });
     }
 
     if (action === "stage") {
       if (file) {
-        await execPromise(`git add ${JSON.stringify(file)}`, { cwd: targetRoot });
+        await git(["add", "--", file], targetRoot);
       } else {
-        await execPromise("git add -A", { cwd: targetRoot });
+        await git(["add", "-A"], targetRoot);
       }
       return NextResponse.json({ success: true });
     }
 
     if (action === "unstage") {
       if (file) {
-        await execPromise(`git reset HEAD -- ${JSON.stringify(file)}`, { cwd: targetRoot });
+        await git(["reset", "HEAD", "--", file], targetRoot);
       } else {
-        await execPromise("git reset HEAD -- .", { cwd: targetRoot });
+        await git(["reset", "HEAD", "--", "."], targetRoot);
       }
       return NextResponse.json({ success: true });
     }
@@ -192,7 +207,7 @@ export async function POST(request: Request) {
       }
       const absolutePath = path.resolve(targetRoot, file).replace(/\\/g, "/");
       // Check status to see if it is untracked
-      const { stdout: statusOut } = await execPromise("git status --porcelain -- " + JSON.stringify(file), { cwd: targetRoot });
+      const { stdout: statusOut } = await git(["status", "--porcelain", "--", file], targetRoot);
       const isUntracked = statusOut.startsWith("??");
 
       if (isUntracked) {
@@ -200,7 +215,7 @@ export async function POST(request: Request) {
           fs.unlinkSync(absolutePath);
         }
       } else {
-        await execPromise(`git checkout -- ${JSON.stringify(file)}`, { cwd: targetRoot });
+        await git(["checkout", "--", file], targetRoot);
       }
       return NextResponse.json({ success: true });
     }
@@ -209,7 +224,7 @@ export async function POST(request: Request) {
       if (!message || !message.trim()) {
         return NextResponse.json({ error: "Commit message cannot be empty" }, { status: 400 });
       }
-      const { stdout } = await execPromise(`git commit -m ${JSON.stringify(message.trim())}`, { cwd: targetRoot });
+      const { stdout } = await git(["commit", "-m", message.trim()], targetRoot);
       return NextResponse.json({ success: true, output: stdout });
     }
 
@@ -231,40 +246,40 @@ export async function POST(request: Request) {
     }
 
     if (action === "pull") {
-      const { stdout, stderr } = await execPromise("git pull", { cwd: targetRoot });
+      const { stdout, stderr } = await git(["pull"], targetRoot);
       return NextResponse.json({ success: true, output: stdout + stderr });
     }
 
     if (action === "push") {
-      const { stdout, stderr } = await execPromise("git push", { cwd: targetRoot });
+      const { stdout, stderr } = await git(["push"], targetRoot);
       return NextResponse.json({ success: true, output: stdout + stderr });
     }
 
     if (action === "checkout") {
       const { branchName } = body;
-      if (!branchName) {
-        return NextResponse.json({ error: "Missing branchName parameter" }, { status: 400 });
+      if (!isValidBranchName(branchName)) {
+        return NextResponse.json({ error: "Missing or invalid branchName parameter" }, { status: 400 });
       }
-      const { stdout, stderr } = await execPromise(`git checkout ${JSON.stringify(branchName)}`, { cwd: targetRoot });
+      const { stdout, stderr } = await git(["checkout", branchName], targetRoot);
       return NextResponse.json({ success: true, output: stdout + stderr });
     }
 
     if (action === "create_branch") {
       const { branchName } = body;
-      if (!branchName) {
-        return NextResponse.json({ error: "Missing branchName parameter" }, { status: 400 });
+      if (!isValidBranchName(branchName)) {
+        return NextResponse.json({ error: "Missing or invalid branchName parameter" }, { status: 400 });
       }
-      const { stdout, stderr } = await execPromise(`git checkout -b ${JSON.stringify(branchName)}`, { cwd: targetRoot });
+      const { stdout, stderr } = await git(["checkout", "-b", branchName], targetRoot);
       return NextResponse.json({ success: true, output: stdout + stderr });
     }
 
     if (action === "delete_branch") {
       const { branchName, force } = body;
-      if (!branchName) {
-        return NextResponse.json({ error: "Missing branchName parameter" }, { status: 400 });
+      if (!isValidBranchName(branchName)) {
+        return NextResponse.json({ error: "Missing or invalid branchName parameter" }, { status: 400 });
       }
       const flag = force ? "-D" : "-d";
-      const { stdout, stderr } = await execPromise(`git branch ${flag} ${JSON.stringify(branchName)}`, { cwd: targetRoot });
+      const { stdout, stderr } = await git(["branch", flag, branchName], targetRoot);
       return NextResponse.json({ success: true, output: stdout + stderr });
     }
 

package/src/app/api/sessions/stats/route.ts

@@ -1,10 +1,24 @@
 import { NextResponse } from "next/server";
 import { SessionManager } from "@/lib/agents/SessionManager";
 import { promisify } from "util";
-import { exec } from "child_process";
+import { execFile } from "child_process";
 import os from "os";
 
-const execPromise = promisify(exec);
+const execFilePromise = promisify(execFile);
+
+// Real per-process stats for the PTY. Returns null when unavailable (pidusage
+// not installed, or no live pid) so callers report honestly instead of faking it.
+async function getProcessStats(pid: number | undefined): Promise<{ cpu: number; memory: number } | null> {
+  if (!pid) return null;
+  try {
+    /* eslint-disable @typescript-eslint/no-require-imports */
+    const pidusage = eval("require")("pidusage");
+    const stat = await pidusage(pid);
+    return { cpu: stat.cpu, memory: stat.memory };
+  } catch {
+    return null;
+  }
+}
 
 export async function GET(request: Request) {
   try {
@@ -21,42 +35,45 @@ export async function GET(request: Request) {
       return NextResponse.json({ error: "Session not found" }, { status: 404 });
     }
 
-    // Default response metrics
+    // Default response metrics. `available` reports whether these are real
+    // measurements (vs. a placeholder when telemetry can't be collected).
     let cpu = "0.0%";
     let memory = "0.0MiB";
     let memoryPercent = "0.0%";
+    let available = false;
 
     if (session.status === "running") {
       const isDocker = session.type === "claude-docker" || session.type === "aider-docker";
       if (isDocker) {
         try {
-          // Query docker stats
+          // Real container stats from the Docker daemon.
           const containerName = `neural-loom-session-${id}`;
-          const { stdout } = await execPromise(`docker stats ${containerName} --no-stream --format "{{.CPUPerc}},{{.MemUsage}},{{.MemPerc}}"`);
-          const parts = stdout.trim().split(",");
+          const { stdout } = await execFilePromise("docker", [
+            "stats",
+            containerName,
+            "--no-stream",
+            "--format",
+            "{{.CPUPerc}},{{.MemUsage}},{{.MemPerc}}",
+          ]);
+          const parts = stdout.toString().trim().split(",");
           if (parts.length >= 3) {
             cpu = parts[0].trim();
-            memory = parts[1].trim().split(" / ")[0]; // get the used part, e.g. "142.2MiB"
+            memory = parts[1].trim().split(" / ")[0]; // used part, e.g. "142.2MiB"
             memoryPercent = parts[2].trim();
+            available = true;
           }
         } catch {
-          // Docker stats not available/running, fallback to simulated telemetry
-          const simulatedCpu = (Math.random() * 3 + 1).toFixed(1) + "%";
-          const simulatedMem = (130 + Math.random() * 20).toFixed(1) + "MiB";
-          const simulatedMemPerc = (1.5 + Math.random() * 0.5).toFixed(2) + "%";
-          cpu = simulatedCpu;
-          memory = simulatedMem;
-          memoryPercent = simulatedMemPerc;
+          // Docker daemon/container not reachable — leave defaults, available=false.
         }
       } else {
-        // Local runner telemetry fallback
-        const simulatedCpu = (Math.random() * 5 + 2).toFixed(1) + "%";
-        const memBytes = process.memoryUsage().rss;
-        const simulatedMem = (memBytes / (1024 * 1024)).toFixed(1) + "MiB";
-        const simulatedMemPerc = ((memBytes / os.totalmem()) * 100).toFixed(2) + "%";
-        cpu = simulatedCpu;
-        memory = simulatedMem;
-        memoryPercent = simulatedMemPerc;
+        // Real per-process stats for the local/SSH PTY process.
+        const stats = await getProcessStats(session.getPid());
+        if (stats) {
+          cpu = stats.cpu.toFixed(1) + "%";
+          memory = (stats.memory / (1024 * 1024)).toFixed(1) + "MiB";
+          memoryPercent = ((stats.memory / os.totalmem()) * 100).toFixed(2) + "%";
+          available = true;
+        }
       }
     }
 
@@ -68,6 +85,7 @@ export async function GET(request: Request) {
       cpu,
       memory,
       memoryPercent,
+      available,
     });
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : "Unknown error";

package/src/app/api/sql/query/route.ts

@@ -1,19 +1,6 @@
 import { NextResponse } from "next/server";
 import { ConnectionManager } from "@/lib/sql/ConnectionManager";
-
-const isMutation = (sql: string): boolean => {
-  const clean = sql.trim().toLowerCase();
-  return (
-    clean.startsWith("insert") ||
-    clean.startsWith("update") ||
-    clean.startsWith("delete") ||
-    clean.startsWith("drop") ||
-    clean.startsWith("alter") ||
-    clean.startsWith("create") ||
-    clean.startsWith("truncate") ||
-    clean.startsWith("replace")
-  );
-};
+import { isReadOnlyViolation } from "@/lib/sql/sqlGuard";
 
 export async function POST(request: Request) {
   try {
@@ -33,7 +20,7 @@ export async function POST(request: Request) {
 
     const { adapter, profile } = active;
 
-    if (profile.readOnly && isMutation(sql)) {
+    if (profile.readOnly && isReadOnlyViolation(sql)) {
       return NextResponse.json({ 
         error: "This connection profile is configured as Read-Only. Modifications are disabled." 
       }, { status: 403 });

package/src/app/api/telemetry/route.ts

@@ -1,10 +1,11 @@
 import { NextResponse } from "next/server";
 import fs from "fs";
 import path from "path";
+import { getConfigDir } from "@/lib/config";
 
 export async function GET() {
   try {
-    const historyFile = path.join(process.cwd(), ".ai", "neural-loom", "token-history.json");
+    const historyFile = path.join(getConfigDir(), "token-history.json");
     if (!fs.existsSync(historyFile)) {
       return NextResponse.json({ success: true, history: [] });
     }