neural-loom 0.1.1

package/src/lib/agents/DockerRunner.ts

@@ -0,0 +1,182 @@
+import fs from "fs";
+import path from "path";
+import type { IPty } from "node-pty";
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { SessionPersister } from "./SessionPersister";
+
+function findGitBash(): string | null {
+  const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+  const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+  const local = process.env.LOCALAPPDATA || "";
+
+  const candidates: string[] = [
+    process.env.WINGMAN_BASH_PATH,
+    path.join(pf, "Git", "bin", "bash.exe"),
+    path.join(pf86, "Git", "bin", "bash.exe"),
+    local ? path.join(local, "Programs", "Git", "bin", "bash.exe") : "",
+  ].filter((p): p is string => typeof p === "string" && p !== "");
+
+  return candidates.find(p => fs.existsSync(p)) || null;
+}
+
+export class DockerRunner extends AgentRunner {
+  id: string;
+  name: string;
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' = 'claude-docker';
+  status: 'idle' | 'running' | 'stopped' = 'idle';
+  createdAt: string;
+  logs: string[] = [];
+
+  private ptyProcess: IPty | null = null;
+  private ptyModule: typeof import("node-pty") | null = null;
+
+  constructor(id: string, name?: string) {
+    super();
+    this.id = id;
+    this.name = name || `Docker Session ${id.substring(0, 8)}`;
+    this.createdAt = new Date().toISOString();
+  }
+
+  private appendLog(line: string) {
+    this.logs.push(line);
+    if (this.logs.length > 5000) {
+      this.logs.shift();
+    }
+    this.parseTokenUsage(line);
+    this.emitOutput(line);
+    SessionPersister.saveSession(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.status === 'running') return;
+
+    this.status = 'running';
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+    this.appendLog("\x1b[1;36m       NEURALLOOM DOCKER SANDBOX RUNTIME BRIDGE    \x1b[0m\r\n");
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+    this.appendLog("[System] Verifying Docker environment accessibility...\r\n");
+
+    const bashPath = findGitBash();
+    if (!bashPath) {
+      this.status = 'stopped';
+      this.appendLog("\x1b[1;31m[System Error] Git Bash not found. Cannot bootstrap PTY sandbox.\x1b[0m\r\n");
+      return;
+    }
+
+    try {
+      if (!this.ptyModule) {
+        this.ptyModule = await import("node-pty");
+      }
+
+      const targetCwd = (this.workspaceRoot && fs.existsSync(this.workspaceRoot)) 
+        ? this.workspaceRoot 
+        : process.cwd();
+
+      // Check if docker executable exists by spawning `docker -v`
+      const testPty = this.ptyModule.spawn(bashPath, ["-c", "docker --version"], {
+        name: "xterm-256color",
+        cols: 80,
+        rows: 10,
+        cwd: targetCwd,
+      });
+
+      let hasDocker = false;
+      testPty.onData((data) => {
+        if (data.toLowerCase().includes("docker version")) {
+          hasDocker = true;
+        }
+      });
+
+      // Wait briefly for docker check
+      await new Promise(resolve => setTimeout(resolve, 800));
+      testPty.kill();
+
+      if (!hasDocker) {
+        this.status = 'stopped';
+        this.appendLog("\x1b[1;31m[Dependency Warning] Docker command not recognized in local PATH.\x1b[0m\r\n");
+        this.appendLog("\x1b[1;33mPlease install Docker Desktop (https://www.docker.com/products/docker-desktop) and ensure the daemon is running.\x1b[0m\r\n");
+        this.appendLog("\x1b[1;31m[System] Sandbox launch aborted.\x1b[0m\r\n");
+        return;
+      }
+
+      // If docker is available, spawn container with mounted workspace
+      this.appendLog("[System] Docker detected. Initializing container mount...\r\n");
+      
+      const mounts: string[] = [`-v "${targetCwd}:/workspace"`];
+      if (this.scopedDirs && Array.isArray(this.scopedDirs)) {
+        this.scopedDirs.forEach((dir) => {
+          if (fs.existsSync(dir)) {
+            const folderName = path.basename(dir).replace(/[^a-zA-Z0-9-_]/g, "_");
+            mounts.push(`-v "${dir}:/scoped/${folderName}"`);
+          }
+        });
+      }
+      const mountsStr = mounts.join(" ");
+
+      const dockerCmd = `docker run -it --name neural-loom-session-${this.id} --rm ${mountsStr} -w /workspace node:20-alpine npx -y @anthropic-ai/claude-code --agents-md`;
+
+      this.ptyProcess = this.ptyModule.spawn(bashPath, ["-c", dockerCmd], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 30,
+        cwd: targetCwd,
+        env: {
+          ...process.env,
+          TERM: "xterm-256color",
+          COLORTERM: "truecolor",
+        },
+      });
+
+      this.ptyProcess.onData((data: string) => {
+        this.appendLog(data);
+      });
+
+      this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+        this.status = 'stopped';
+        this.appendLog(`\r\n\x1b[1;31m[System] Docker Sandbox exited (code=${exitCode}, signal=${signal}).\x1b[0m\r\n`);
+        this.ptyProcess = null;
+      });
+
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error";
+      this.status = 'stopped';
+      this.appendLog(`\x1b[1;31m[System Error] Failed to launch Docker runner: ${errorMessage}\x1b[0m\r\n`);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.status = 'stopped';
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.kill();
+      } catch (err) {
+        console.error("Error killing Docker PTY process:", err);
+      }
+      this.ptyProcess = null;
+    }
+    this.appendLog("\r\n\x1b[1;31m[System] Docker container stopped and unmounted.\x1b[0m\r\n");
+  }
+
+  async sendInput(text: string, isRaw = false): Promise<void> {
+    if (this.status !== 'running' || !this.ptyProcess) {
+      this.appendLog(`\r\n\x1b[1;31m[Error] Cannot write: Docker container is ${this.status}.\x1b[0m\r\n`);
+      return;
+    }
+
+    this.ptyProcess.write(isRaw ? text : text + "\r");
+  }
+
+  getStatus(): RunnerStatus {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      workspaceRoot: this.workspaceRoot,
+      scopedDirs: this.scopedDirs,
+      tokenUsage: this.tokenUsage
+    };
+  }
+}

package/src/lib/agents/MockRunner.ts

@@ -0,0 +1,126 @@
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { SessionPersister } from "./SessionPersister";
+
+export class MockRunner extends AgentRunner {
+  id: string;
+  name: string;
+  type: 'mock' | 'claude' = 'mock';
+  status: 'idle' | 'running' | 'stopped' = 'idle';
+  createdAt: string;
+  logs: string[] = [];
+  
+  private intervalId: NodeJS.Timeout | null = null;
+  private mockSteps = [
+    "[NeuralLoom] Loading virtual PTY context...",
+    "[NeuralLoom] Spawning sandbox mock runtime environment...",
+    "[Mock Agent] Model online (v2.0-mock-flash). Dedicated memory allocated.",
+    "[Mock Agent] System rules parsed successfully from global context registry.",
+    "[Mock Agent] Awaiting developer commands. Type '/help' to list mock skills."
+  ];
+  private stepIndex = 0;
+
+  constructor(id: string, name?: string) {
+    super();
+    this.id = id;
+    this.name = name || `Mock Session ${id.substring(0, 8)}`;
+    this.createdAt = new Date().toISOString();
+  }
+
+  private appendLog(line: string) {
+    this.logs.push(line);
+    this.parseTokenUsage(line);
+    this.emitOutput(line + "\r\n");
+    SessionPersister.saveSession(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.status === 'running') return;
+    this.status = 'running';
+    
+    // Add banner
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m");
+    this.appendLog("\x1b[1;36m       NEURALLOOM SIMULATED AGENT ENVIRONMENT     \x1b[0m");
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m");
+    
+    // Post initial log immediately
+    if (this.stepIndex < this.mockSteps.length) {
+      this.appendLog(this.mockSteps[this.stepIndex++]);
+    }
+
+    // Schedule subsequent logs
+    this.intervalId = setInterval(() => {
+      this.tokenUsage.input += Math.floor(Math.random() * 50) + 10;
+      this.tokenUsage.output += Math.floor(Math.random() * 20) + 5;
+      this.tokenUsage.cost = (this.tokenUsage.input * 0.000003) + (this.tokenUsage.output * 0.000015);
+
+      if (this.stepIndex < this.mockSteps.length) {
+        this.appendLog(this.mockSteps[this.stepIndex++]);
+      } else {
+        // Just general ambient telemetry mock log
+        const time = new Date().toLocaleTimeString();
+        this.appendLog(`[${time}] [Telemetry] CPU utilization 1.2% | Memory 142MB | Link stable.`);
+      }
+    }, 4000);
+  }
+
+  async stop(): Promise<void> {
+    this.status = 'stopped';
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+    this.appendLog("\x1b[1;31m[System] Process terminated. Connection closed.\x1b[0m");
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async sendInput(text: string, _isRaw?: boolean): Promise<void> {
+    if (this.status !== 'running') {
+      this.appendLog(`\x1b[1;31m[Error] Cannot write input: process is ${this.status}.\x1b[0m`);
+      return;
+    }
+    
+    // Echo the command back as user prompt
+    this.appendLog(`\x1b[1;32m> ${text}\x1b[0m`);
+
+    // Simulated parser responses
+    setTimeout(() => {
+      const cleanInput = text.trim().toLowerCase();
+      if (cleanInput === '/help') {
+        this.appendLog("[Mock Agent] Available commands:");
+        this.appendLog("  /help      - List available mock commands.");
+        this.appendLog("  /status    - Fetch current agent diagnostic metrics.");
+        this.appendLog("  /context   - View loaded staging files.");
+        this.appendLog("  /clear     - Flush terminal console buffer.");
+      } else if (cleanInput === '/status') {
+        this.appendLog("[Mock Agent] Diagnostics:");
+        this.appendLog("  - Connection Type: WebSocket gateway (mock)");
+        this.appendLog(`  - Active Runtime: ${this.id}`);
+        this.appendLog("  - Sandbox State: Healthy (0 warnings)");
+      } else if (cleanInput === '/context') {
+        this.appendLog("[Mock Agent] Loaded Workspace Context Files:");
+        this.appendLog("  - [Mounted] src/app/globals.css (Modified)");
+        this.appendLog("  - [Mounted] src/app/page.tsx");
+      } else if (cleanInput === '/clear') {
+        this.logs = [];
+        this.appendLog("\x1b[1;33m[Console Cleared]\x1b[0m");
+      } else {
+        this.appendLog(`[Mock Agent] Received command: "${text}". Processing...`);
+        setTimeout(() => {
+          this.appendLog(`[Mock Agent] Done. Task simulated successfully.`);
+        }, 1500);
+      }
+    }, 400);
+  }
+
+  getStatus(): RunnerStatus {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      tokenUsage: this.tokenUsage
+    };
+  }
+}

package/src/lib/agents/SSHRunner.ts

@@ -0,0 +1,180 @@
+import fs from "fs";
+import path from "path";
+import type { IPty } from "node-pty";
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { SessionPersister } from "./SessionPersister";
+
+function findGitBash(): string | null {
+  const pf = process.env.PROGRAMFILES || "C:\\Program Files";
+  const pf86 = process.env["PROGRAMFILES(X86)"] || "C:\\Program Files (x86)";
+  const local = process.env.LOCALAPPDATA || "";
+
+  const candidates: string[] = [
+    process.env.WINGMAN_BASH_PATH,
+    path.join(pf, "Git", "bin", "bash.exe"),
+    path.join(pf86, "Git", "bin", "bash.exe"),
+    local ? path.join(local, "Programs", "Git", "bin", "bash.exe") : "",
+  ].filter((p): p is string => typeof p === "string" && p !== "");
+
+  return candidates.find(p => fs.existsSync(p)) || null;
+}
+
+interface SSHConfig {
+  host: string;
+  username: string;
+  privateKeyPath?: string;
+  port?: number;
+}
+
+export class SSHRunner extends AgentRunner {
+  id: string;
+  name: string;
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' = 'claude-ssh';
+  status: 'idle' | 'running' | 'stopped' = 'idle';
+  createdAt: string;
+  logs: string[] = [];
+
+  private ptyProcess: IPty | null = null;
+  private ptyModule: typeof import("node-pty") | null = null;
+
+  constructor(id: string, name?: string) {
+    super();
+    this.id = id;
+    this.name = name || `SSH Session ${id.substring(0, 8)}`;
+    this.createdAt = new Date().toISOString();
+  }
+
+  private appendLog(line: string) {
+    this.logs.push(line);
+    if (this.logs.length > 5000) {
+      this.logs.shift();
+    }
+    this.parseTokenUsage(line);
+    this.emitOutput(line);
+    SessionPersister.saveSession(this);
+  }
+
+  async start(): Promise<void> {
+    if (this.status === 'running') return;
+
+    this.status = 'running';
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+    this.appendLog("\x1b[1;36m       NEURALLOOM REMOTE VM (SSH) ROUTE BRIDGE     \x1b[0m\r\n");
+    this.appendLog("\x1b[1;35m==================================================\x1b[0m\r\n");
+    this.appendLog("[System] Loading SSH configuration...\r\n");
+
+    const bashPath = findGitBash();
+    if (!bashPath) {
+      this.status = 'stopped';
+      this.appendLog("\x1b[1;31m[System Error] Git Bash not found. Cannot bootstrap SSH terminal.\x1b[0m\r\n");
+      return;
+    }
+
+    const configPath = path.join(process.cwd(), ".ai", "neural-loom", "ssh.json");
+    if (!fs.existsSync(configPath)) {
+      this.status = 'stopped';
+      this.appendLog("\x1b[1;31m[Configuration Error] ssh.json not found!\x1b[0m\r\n");
+      this.appendLog(`\x1b[1;33mPlease create the SSH credentials file at: ${configPath}\x1b[0m\r\n`);
+      this.appendLog("\x1b[1;36mTemplate structure:\x1b[0m\r\n");
+      this.appendLog(
+        JSON.stringify(
+          {
+            host: "your.remote.host.com",
+            username: "dave",
+            privateKeyPath: "C:\\\\Users\\\\Dave\\\\.ssh\\\\id_rsa",
+            port: 22,
+          },
+          null,
+          2
+        ).replace(/\n/g, "\r\n") + "\r\n"
+      );
+      this.appendLog("\x1b[1;31m[System] SSH startup aborted.\x1b[0m\r\n");
+      return;
+    }
+
+    try {
+      const rawConfig = fs.readFileSync(configPath, "utf8");
+      const config: SSHConfig = JSON.parse(rawConfig);
+
+      if (!config.host || !config.username) {
+        this.status = 'stopped';
+        this.appendLog("\x1b[1;31m[System Error] Invalid ssh.json configuration. 'host' and 'username' are required.\x1b[0m\r\n");
+        return;
+      }
+
+      if (!this.ptyModule) {
+        this.ptyModule = await import("node-pty");
+      }
+
+      this.appendLog(`[System] Connecting to ${config.username}@${config.host}...\r\n`);
+
+      const portOpt = config.port ? `-p ${config.port}` : "";
+      const keyOpt = config.privateKeyPath ? `-i "${config.privateKeyPath}"` : "";
+      
+      const sshCmd = `ssh -t ${keyOpt} ${portOpt} ${config.username}@${config.host} "claude --agents-md"`;
+
+      this.ptyProcess = this.ptyModule.spawn(bashPath, ["-c", sshCmd], {
+        name: "xterm-256color",
+        cols: 120,
+        rows: 30,
+        cwd: process.cwd(),
+        env: {
+          ...process.env,
+          TERM: "xterm-256color",
+          COLORTERM: "truecolor",
+        },
+      });
+
+      this.ptyProcess.onData((data: string) => {
+        this.appendLog(data);
+      });
+
+      this.ptyProcess.onExit(({ exitCode, signal }: { exitCode: number; signal?: number }) => {
+        this.status = 'stopped';
+        this.appendLog(`\r\n\x1b[1;31m[System] SSH Session exited (code=${exitCode}, signal=${signal}).\x1b[0m\r\n`);
+        this.ptyProcess = null;
+      });
+
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : "Unknown error";
+      this.status = 'stopped';
+      this.appendLog(`\x1b[1;31m[System Error] SSH connection failed: ${errorMessage}\x1b[0m\r\n`);
+    }
+  }
+
+  async stop(): Promise<void> {
+    this.status = 'stopped';
+    if (this.ptyProcess) {
+      try {
+        this.ptyProcess.kill();
+      } catch (err) {
+        console.error("Error killing SSH PTY process:", err);
+      }
+      this.ptyProcess = null;
+    }
+    this.appendLog("\r\n\x1b[1;31m[System] SSH Connection terminated.\x1b[0m\r\n");
+  }
+
+  async sendInput(text: string, isRaw = false): Promise<void> {
+    if (this.status !== 'running' || !this.ptyProcess) {
+      this.appendLog(`\r\n\x1b[1;31m[Error] Cannot write: SSH session is ${this.status}.\x1b[0m\r\n`);
+      return;
+    }
+
+    this.ptyProcess.write(isRaw ? text : text + "\r");
+  }
+
+  getStatus(): RunnerStatus {
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      workspaceRoot: this.workspaceRoot,
+      scopedDirs: this.scopedDirs,
+      tokenUsage: this.tokenUsage
+    };
+  }
+}

package/src/lib/agents/SessionManager.ts

@@ -0,0 +1,147 @@
+import crypto from "crypto";
+import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { MockRunner } from "./MockRunner";
+import { ClaudeRunner } from "./ClaudeRunner";
+import { DockerRunner } from "./DockerRunner";
+import { SSHRunner } from "./SSHRunner";
+import { AiderRunner } from "./AiderRunner";
+import { initWebSocketServer } from "./WebSocketServer";
+import { ContextManager } from "./ContextManager";
+import { SessionPersister } from "./SessionPersister";
+
+export class SessionManager {
+  private static instance: SessionManager | null = null;
+  private sessions = new Map<string, AgentRunner>();
+
+  private constructor() {
+    // Bootstrap staging filesystem and slash commands
+    ContextManager.initializeStaging();
+    ContextManager.compileGlobalRules();
+
+    // Reload persisted sessions
+    try {
+      const saved = SessionPersister.loadAllSessions();
+      for (const data of saved) {
+        let runner: AgentRunner;
+        if (data.type === "mock") {
+          runner = new MockRunner(data.id, data.name);
+        } else if (data.type === "claude-docker") {
+          runner = new DockerRunner(data.id, data.name);
+        } else if (data.type === "claude-ssh") {
+          runner = new SSHRunner(data.id, data.name);
+        } else if (data.type === "aider" || data.type === "aider-docker") {
+          runner = new AiderRunner(data.id, data.type as 'aider' | 'aider-docker', data.name);
+        } else {
+          runner = new ClaudeRunner(data.id, data.name);
+        }
+
+        runner.status = data.status;
+        runner.createdAt = data.createdAt;
+        runner.logs = data.logs;
+        runner.workspaceRoot = data.workspaceRoot;
+        runner.scopedDirs = data.scopedDirs;
+
+        // Auto-resume mock runner if running
+        if (data.type === "mock" && data.status === "running") {
+          runner.start();
+        }
+
+        this.sessions.set(data.id, runner);
+      }
+    } catch (err) {
+      console.error("[SessionManager] Failed to reload saved sessions:", err);
+    }
+  }
+
+  public static getInstance(): SessionManager {
+    if (!SessionManager.instance) {
+      SessionManager.instance = new SessionManager();
+      // Initialize WebSocket gateway server on port 3001
+      initWebSocketServer(3001);
+    }
+    return SessionManager.instance;
+  }
+
+  private generateId(): string {
+    return crypto.randomUUID();
+  }
+
+  public async createSession(
+    type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker',
+    name?: string,
+    workspaceRoot?: string,
+    scopedDirs?: string[]
+  ): Promise<AgentRunner> {
+    const id = this.generateId();
+    let runner: AgentRunner;
+
+    if (type === 'mock') {
+      runner = new MockRunner(id, name);
+    } else if (type === 'claude-docker') {
+      runner = new DockerRunner(id, name);
+    } else if (type === 'claude-ssh') {
+      runner = new SSHRunner(id, name);
+    } else if (type === 'aider' || type === 'aider-docker') {
+      runner = new AiderRunner(id, type, name);
+    } else {
+      runner = new ClaudeRunner(id, name);
+    }
+
+    runner.workspaceRoot = workspaceRoot;
+    runner.scopedDirs = scopedDirs;
+
+    await runner.start();
+    this.sessions.set(id, runner);
+    SessionPersister.saveSession(runner);
+    return runner;
+  }
+
+  public getSession(id: string): AgentRunner | undefined {
+    return this.sessions.get(id);
+  }
+
+  public listSessions(): RunnerStatus[] {
+    return Array.from(this.sessions.values()).map(runner => runner.getStatus());
+  }
+
+  public async stopSession(id: string): Promise<boolean> {
+    const runner = this.sessions.get(id);
+    if (!runner) return false;
+    await runner.stop();
+    SessionPersister.saveSession(runner);
+    return true;
+  }
+
+  public async deleteSession(id: string): Promise<boolean> {
+    const runner = this.sessions.get(id);
+    if (runner) {
+      await runner.stop();
+    }
+    SessionPersister.deleteSession(id);
+    return this.sessions.delete(id);
+  }
+
+  public async injectCommand(id: string, command: string): Promise<boolean> {
+    const runner = this.sessions.get(id);
+    if (!runner || runner.status !== 'running') return false;
+
+    const root = runner.workspaceRoot || process.cwd();
+
+    if (command === '/ccc' || command === '/ccp') {
+      ContextManager.compileSessionContext(root, runner.scopedDirs);
+    }
+
+    let finalCommand = command;
+    if (runner.type === 'aider' || runner.type === 'aider-docker') {
+      if (command === '/ccc') {
+        finalCommand = "/read .ai/neural-loom/ccontext.md";
+      } else if (command === '/ccp') {
+        finalCommand = "/read .ai/neural-loom/cprompt.md";
+      }
+    }
+
+    // Inject Ctrl+U to clear input, then command, then Enter (\r)
+    await runner.sendInput("\x15" + finalCommand + "\r", true);
+    return true;
+  }
+}