neural-loom 0.1.1

package/src/lib/agents/SessionPersister.ts

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+
+export interface PersistedSession {
+  id: string;
+  name: string;
+  type: string;
+  status: 'idle' | 'running' | 'stopped';
+  createdAt: string;
+  logs: string[];
+  workspaceRoot?: string;
+  scopedDirs?: string[];
+}
+
+export class SessionPersister {
+  private static workspaceRoot = process.cwd();
+
+  private static getSessionsDir(): string {
+    const dir = path.join(this.workspaceRoot, ".ai", "neural-loom", "sessions");
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+  }
+
+  public static saveSession(session: { id: string; name: string; type: string; status: string; createdAt: string; logs: string[]; workspaceRoot?: string; scopedDirs?: string[] }) {
+    try {
+      const dir = this.getSessionsDir();
+      const filePath = path.join(dir, `${session.id}.json`);
+      const data: PersistedSession = {
+        id: session.id,
+        name: session.name,
+        type: session.type,
+        status: (session.status === 'running' && session.type === 'mock') ? 'running' : session.status as 'idle' | 'running' | 'stopped', // Mock sessions can persist as running or restart
+        createdAt: session.createdAt,
+        logs: session.logs,
+        workspaceRoot: session.workspaceRoot,
+        scopedDirs: session.scopedDirs
+      };
+      fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+    } catch (err) {
+      console.error(`[SessionPersister] Failed to save session ${session.id}:`, err);
+    }
+  }
+
+  public static loadAllSessions(): PersistedSession[] {
+    try {
+      const dir = this.getSessionsDir();
+      const files = fs.readdirSync(dir);
+      const sessions: PersistedSession[] = [];
+
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          const filePath = path.join(dir, file);
+          const raw = fs.readFileSync(filePath, "utf8");
+          const data: PersistedSession = JSON.parse(raw);
+          // On server restart, active PTY processes (which are dead) are marked stopped
+          if (data.status === "running" && data.type !== "mock") {
+            data.status = "stopped";
+            data.logs.push("\r\n\x1b[1;31m[System] Server restarted. Terminal connection lost.\x1b[0m\r\n");
+            // Save the updated status back to disk
+            fs.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf8");
+          }
+          sessions.push(data);
+        }
+      }
+      return sessions;
+    } catch (err) {
+      console.error("[SessionPersister] Failed to load sessions:", err);
+      return [];
+    }
+  }
+
+  public static deleteSession(id: string) {
+    try {
+      const dir = this.getSessionsDir();
+      const filePath = path.join(dir, `${id}.json`);
+      if (fs.existsSync(filePath)) {
+        fs.unlinkSync(filePath);
+      }
+    } catch (err) {
+      console.error(`[SessionPersister] Failed to delete session ${id}:`, err);
+    }
+  }
+}

package/src/lib/agents/WebSocketServer.ts

@@ -0,0 +1,118 @@
+import { WebSocketServer, WebSocket } from "ws";
+import { SessionManager } from "./SessionManager";
+
+declare global {
+  var wss: WebSocketServer | undefined;
+}
+
+export function initWebSocketServer(port = 3001) {
+  // Prevent duplicate WebSocket servers during hot reloads in development
+  if (global.wss) {
+    console.log("[WebSocketServer] WebSocket Server already active on port 3001 (cached).");
+    return;
+  }
+
+  console.log(`[WebSocketServer] Launching NeuralLoom WebSocket Gateway on port ${port}...`);
+
+  try {
+    const wss = new WebSocketServer({ port });
+    global.wss = wss;
+
+    wss.on("connection", (ws: WebSocket & { sessionId?: string }) => {
+      console.log("[WebSocketServer] New client connected via gateway.");
+
+      let activeSessionId: string | null = null;
+      let outputListener: ((data: string) => void) | null = null;
+      let mockBuffer = "";
+
+      ws.on("message", async (rawMsg) => {
+        try {
+          const msg = JSON.parse(rawMsg.toString());
+
+          // Client handshake to establish connection to a specific session
+          if (msg.type === "handshake") {
+            const { sessionId } = msg;
+            const manager = SessionManager.getInstance();
+            const session = manager.getSession(sessionId);
+
+            if (session) {
+              activeSessionId = sessionId;
+              ws.sessionId = sessionId;
+              console.log(`[WebSocketServer] Client connected to active session: ${sessionId}`);
+
+              // Subscribe to runner output events
+              outputListener = (data: string) => {
+                if (ws.readyState === WebSocket.OPEN) {
+                  ws.send(JSON.stringify({ type: "output", data }));
+                }
+              };
+              session.onOutput(outputListener);
+
+              // Send handshake acknowledgment and full historical logs
+              ws.send(
+                JSON.stringify({
+                  type: "handshake-ack",
+                  sessionId,
+                  history: session.logs.join(""),
+                })
+              );
+            } else {
+              ws.send(JSON.stringify({ type: "error", message: "Requested session not found" }));
+            }
+          }
+
+          // User terminal input routing
+          if (msg.type === "input" && activeSessionId) {
+            const manager = SessionManager.getInstance();
+            const session = manager.getSession(activeSessionId);
+            if (session && session.status === "running") {
+              if (session.type === "mock") {
+                // Buffer input for simulated command parsing in MockRunner
+                const data = msg.data;
+                if (data === "\r" || data === "\r\n") {
+                  ws.send(JSON.stringify({ type: "output", data: "\r\n" }));
+                  const cmd = mockBuffer;
+                  mockBuffer = "";
+                  await session.sendInput(cmd);
+                } else if (data === "\u007f" || data === "\b") { // Backspace
+                  if (mockBuffer.length > 0) {
+                    mockBuffer = mockBuffer.slice(0, -1);
+                    ws.send(JSON.stringify({ type: "output", data: "\b \b" }));
+                  }
+                } else {
+                  mockBuffer += data;
+                  ws.send(JSON.stringify({ type: "output", data })); // Local echo of key
+                }
+              } else {
+                // Pass raw keystrokes straight to Claude Code PTY
+                await session.sendInput(msg.data, true);
+              }
+            }
+          }
+        } catch (err) {
+          console.error("[WebSocketServer] Error processing socket packet:", err);
+        }
+      });
+
+      ws.on("close", () => {
+        if (activeSessionId && outputListener) {
+          const manager = SessionManager.getInstance();
+          const session = manager.getSession(activeSessionId);
+          if (session) {
+            session.offOutput(outputListener);
+          }
+        }
+        console.log("[WebSocketServer] Client connection closed.");
+      });
+
+      ws.on("error", (err) => {
+        console.error("[WebSocketServer] Socket error:", err);
+      });
+    });
+
+    console.log(`[WebSocketServer] WebSocket gateway successfully listening on port ${port}.`);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    console.error(`[WebSocketServer] Failed to initialize WebSocket Server: ${errorMessage}`);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}