neural-loom 0.2.60 → 0.2.61

package/src/lib/agents/AgentRunner.ts

@@ -1,3 +1,6 @@
+import fs from "fs";
+import path from "path";
+
 export interface RunnerStatus {
   id: string;
   name: string;
@@ -12,6 +15,19 @@ export interface RunnerStatus {
   agentState?: 'idle' | 'thinking' | 'complete' | 'needs-input';
 }
 
+export interface TokenTransaction {
+  timestamp: string;
+  sessionId: string;
+  sessionName: string;
+  type: string;
+  inputTokens: number;
+  outputTokens: number;
+  cost: number;
+  totalInput: number;
+  totalOutput: number;
+  totalCost: number;
+}
+
 export abstract class AgentRunner {
   abstract id: string;
   abstract name: string;
@@ -25,6 +41,57 @@ export abstract class AgentRunner {
   tokenUsage: { input: number; output: number; cost: number } = { input: 0, output: 0, cost: 0 };
   agentState: 'idle' | 'thinking' | 'complete' | 'needs-input' = 'idle';
   private stateTimer: NodeJS.Timeout | null = null;
+  private lastLoggedUsage = { input: 0, output: 0, cost: 0 };
+
+  protected logTokenUsageUpdate(): void {
+    if (
+      this.tokenUsage.input === this.lastLoggedUsage.input &&
+      this.tokenUsage.output === this.lastLoggedUsage.output &&
+      this.tokenUsage.cost === this.lastLoggedUsage.cost
+    ) {
+      return;
+    }
+
+    const diffInput = this.tokenUsage.input - this.lastLoggedUsage.input;
+    const diffOutput = this.tokenUsage.output - this.lastLoggedUsage.output;
+    const diffCost = this.tokenUsage.cost - this.lastLoggedUsage.cost;
+
+    if (diffInput > 0 || diffOutput > 0 || diffCost > 0) {
+      try {
+        const configDir = path.join(process.cwd(), ".ai", "neural-loom");
+        if (!fs.existsSync(configDir)) {
+          fs.mkdirSync(configDir, { recursive: true });
+        }
+        const historyFile = path.join(configDir, "token-history.json");
+        let history: TokenTransaction[] = [];
+        if (fs.existsSync(historyFile)) {
+          try {
+            history = JSON.parse(fs.readFileSync(historyFile, "utf8")) || [];
+          } catch {
+            history = [];
+          }
+        }
+
+        history.push({
+          timestamp: new Date().toISOString(),
+          sessionId: this.id,
+          sessionName: this.name,
+          type: this.type,
+          inputTokens: diffInput > 0 ? diffInput : 0,
+          outputTokens: diffOutput > 0 ? diffOutput : 0,
+          cost: diffCost > 0 ? diffCost : 0,
+          totalInput: this.tokenUsage.input,
+          totalOutput: this.tokenUsage.output,
+          totalCost: this.tokenUsage.cost
+        });
+
+        fs.writeFileSync(historyFile, JSON.stringify(history, null, 2), "utf8");
+        this.lastLoggedUsage = { ...this.tokenUsage };
+      } catch (err) {
+        console.error("[AgentRunner] Failed to log token usage transaction:", err);
+      }
+    }
+  }
 
   protected parseTokenUsage(data: string): void {
     const cleanData = data.replace(/\x1b\[[0-9;]*m/g, ""); // Strip ANSI colors
@@ -68,14 +135,30 @@ export abstract class AgentRunner {
     if (this.tokenUsage.cost === 0 && (this.tokenUsage.input > 0 || this.tokenUsage.output > 0)) {
       this.tokenUsage.cost = (this.tokenUsage.input * 0.000003) + (this.tokenUsage.output * 0.000015);
     }
+    this.logTokenUsageUpdate();
   }
 
-  abstract start(): Promise<void>;
+  abstract start(resume?: boolean): Promise<void>;
   abstract stop(): Promise<void>;
   abstract sendInput(text: string, isRaw?: boolean): Promise<void>;
-  abstract getStatus(): RunnerStatus;
+  getStatus(): RunnerStatus {
+    this.analyzeState();
+    return {
+      id: this.id,
+      name: this.name,
+      type: this.type,
+      status: this.status,
+      createdAt: this.createdAt,
+      logsCount: this.logs.length,
+      workspaceRoot: this.workspaceRoot || (this.type === 'shell' ? (process.env.ORIGINAL_CWD || process.cwd()) : undefined),
+      scopedDirs: this.scopedDirs,
+      lastSyncedWorkspaceFolders: this.lastSyncedWorkspaceFolders,
+      tokenUsage: this.tokenUsage,
+      agentState: this.agentState
+    };
+  }
   
-  resize(cols: number, rows: number): void {
+  resize(_cols: number, _rows: number): void {
     // No-op by default, overridden by PTY runners
   }
 
@@ -129,14 +212,14 @@ export abstract class AgentRunner {
     }, 800);
   }
 
-  private analyzeState(): void {
+  protected analyzeState(): void {
     if (this.status !== 'running') {
       this.agentState = 'idle';
       return;
     }
 
     const tailLines = this.logs.slice(-5).join("");
-    const cleanTail = tailLines.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "").trim();
+    const cleanTail = tailLines.replace(/\x1b(?:\[[0-9;]*[a-zA-Z]|\([a-zA-Z]|\)[a-zA-Z])/g, "").trim();
 
     const isQuestion = 
       /(\[y\/n\]|\(y\/n\)|\?|confirm|allow|should I|would you|press enter|proceed)/i.test(cleanTail);

package/src/lib/agents/AiderRunner.ts

@@ -3,7 +3,7 @@ import path from "path";
 import { exec } from "child_process";
 import { getConfigDir } from "../config";
 import type { IPty } from "node-pty";
-import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { AgentRunner } from "./AgentRunner";
 import { SessionPersister } from "./SessionPersister";
 
 function isWindows(): boolean {
@@ -71,7 +71,7 @@ function getFilesForAider(dir: string): string {
 export class AiderRunner extends AgentRunner {
   id: string;
   name: string;
-  type: 'aider' | 'aider-docker';
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell';
   status: 'idle' | 'running' | 'stopped' = 'idle';
   createdAt: string;
   logs: string[] = [];
@@ -97,7 +97,7 @@ export class AiderRunner extends AgentRunner {
     SessionPersister.saveSession(this);
   }
 
-  async start(): Promise<void> {
+  async start(resume?: boolean): Promise<void> {
     if (this.status === 'running') return;
 
     this.status = 'running';
@@ -304,19 +304,5 @@ export class AiderRunner extends AgentRunner {
       }
     }
   }
-
-  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,
-      agentState: this.agentState
-    };
-  }
 }
+

package/src/lib/agents/ClaudeRunner.ts

@@ -4,7 +4,7 @@ import os from "os";
 import { execSync } from "child_process";
 import { getConfigDir } from "../config";
 import type { IPty } from "node-pty";
-import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { AgentRunner } from "./AgentRunner";
 import { SessionPersister } from "./SessionPersister";
 
 function isWindows(): boolean {
@@ -32,7 +32,7 @@ function findGitBash(): string | null {
 export class ClaudeRunner extends AgentRunner {
   id: string;
   name: string;
-  type: 'mock' | 'claude' = 'claude';
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell' = 'claude';
   status: 'idle' | 'running' | 'stopped' = 'idle';
   createdAt: string;
   logs: string[] = [];
@@ -57,7 +57,7 @@ export class ClaudeRunner extends AgentRunner {
     SessionPersister.saveSession(this);
   }
 
-  async start(): Promise<void> {
+  async start(resume?: boolean): Promise<void> {
     if (this.status === 'running') return;
 
     // Detect Git Bash on Windows
@@ -87,15 +87,19 @@ export class ClaudeRunner extends AgentRunner {
 
       // Load Claude configuration to check for extraFlags (like --resume)
       let extraFlags = "";
-      const claudeConfigPath = path.join(getConfigDir(), "claude.json");
-      if (fs.existsSync(claudeConfigPath)) {
-        try {
-          const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
-          if (config.extraFlags) {
-            extraFlags = config.extraFlags;
+      if (resume) {
+        extraFlags = "--resume";
+      } else {
+        const claudeConfigPath = path.join(getConfigDir(), "claude.json");
+        if (fs.existsSync(claudeConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
+            if (config.extraFlags) {
+              extraFlags = config.extraFlags;
+            }
+          } catch (err) {
+            console.error("Failed to parse Claude configuration:", err);
           }
-        } catch (err) {
-          console.error("Failed to parse Claude configuration:", err);
         }
       }
 
@@ -194,19 +198,5 @@ export class ClaudeRunner extends AgentRunner {
       }
     }
   }
-
-  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,
-      agentState: this.agentState
-    };
-  }
 }
+

package/src/lib/agents/DockerRunner.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { getConfigDir } from "../config";
 import type { IPty } from "node-pty";
-import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { AgentRunner } from "./AgentRunner";
 import { SessionPersister } from "./SessionPersister";
 
 function isWindows(): boolean {
@@ -30,7 +30,7 @@ function findGitBash(): string | null {
 export class DockerRunner extends AgentRunner {
   id: string;
   name: string;
-  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' = 'claude-docker';
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell' = 'claude-docker';
   status: 'idle' | 'running' | 'stopped' = 'idle';
   createdAt: string;
   logs: string[] = [];
@@ -55,7 +55,7 @@ export class DockerRunner extends AgentRunner {
     SessionPersister.saveSession(this);
   }
 
-  async start(): Promise<void> {
+  async start(resume?: boolean): Promise<void> {
     if (this.status === 'running') return;
 
     this.status = 'running';
@@ -123,15 +123,19 @@ export class DockerRunner extends AgentRunner {
 
       // Load Claude configuration to check for extraFlags (like --resume)
       let extraFlags = "";
-      const claudeConfigPath = path.join(getConfigDir(), "claude.json");
-      if (fs.existsSync(claudeConfigPath)) {
-        try {
-          const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
-          if (config.extraFlags) {
-            extraFlags = config.extraFlags;
+      if (resume) {
+        extraFlags = "--resume";
+      } else {
+        const claudeConfigPath = path.join(getConfigDir(), "claude.json");
+        if (fs.existsSync(claudeConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
+            if (config.extraFlags) {
+              extraFlags = config.extraFlags;
+            }
+          } catch (err) {
+            console.error("Failed to parse Claude configuration:", err);
           }
-        } catch (err) {
-          console.error("Failed to parse Claude configuration:", err);
         }
       }
 
@@ -198,19 +202,5 @@ export class DockerRunner extends AgentRunner {
       }
     }
   }
-
-  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,
-      agentState: this.agentState
-    };
-  }
 }
+

package/src/lib/agents/MockRunner.ts

@@ -1,10 +1,10 @@
-import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { AgentRunner } from "./AgentRunner";
 import { SessionPersister } from "./SessionPersister";
 
 export class MockRunner extends AgentRunner {
   id: string;
   name: string;
-  type: 'mock' | 'claude' = 'mock';
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell' = 'mock';
   status: 'idle' | 'running' | 'stopped' = 'idle';
   createdAt: string;
   logs: string[] = [];
@@ -33,7 +33,7 @@ export class MockRunner extends AgentRunner {
     SessionPersister.saveSession(this);
   }
 
-  async start(): Promise<void> {
+  async start(resume?: boolean): Promise<void> {
     if (this.status === 'running') return;
     this.status = 'running';
     
@@ -111,17 +111,5 @@ export class MockRunner extends AgentRunner {
       }
     }, 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,
-      agentState: this.agentState
-    };
-  }
 }
+

package/src/lib/agents/SSHRunner.ts

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { getConfigDir } from "../config";
 import type { IPty } from "node-pty";
-import { AgentRunner, RunnerStatus } from "./AgentRunner";
+import { AgentRunner } from "./AgentRunner";
 import { SessionPersister } from "./SessionPersister";
 
 function isWindows(): boolean {
@@ -37,7 +37,7 @@ interface SSHConfig {
 export class SSHRunner extends AgentRunner {
   id: string;
   name: string;
-  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' = 'claude-ssh';
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell' = 'claude-ssh';
   status: 'idle' | 'running' | 'stopped' = 'idle';
   createdAt: string;
   logs: string[] = [];
@@ -62,7 +62,7 @@ export class SSHRunner extends AgentRunner {
     SessionPersister.saveSession(this);
   }
 
-  async start(): Promise<void> {
+  async start(resume?: boolean): Promise<void> {
     if (this.status === 'running') return;
 
     this.status = 'running';
@@ -121,15 +121,19 @@ export class SSHRunner extends AgentRunner {
       
       // Load Claude configuration to check for extraFlags (like --resume)
       let extraFlags = "";
-      const claudeConfigPath = path.join(getConfigDir(), "claude.json");
-      if (fs.existsSync(claudeConfigPath)) {
-        try {
-          const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
-          if (config.extraFlags) {
-            extraFlags = config.extraFlags;
+      if (resume) {
+        extraFlags = "--resume";
+      } else {
+        const claudeConfigPath = path.join(getConfigDir(), "claude.json");
+        if (fs.existsSync(claudeConfigPath)) {
+          try {
+            const config = JSON.parse(fs.readFileSync(claudeConfigPath, "utf8"));
+            if (config.extraFlags) {
+              extraFlags = config.extraFlags;
+            }
+          } catch (err) {
+            console.error("Failed to parse Claude configuration:", err);
           }
-        } catch (err) {
-          console.error("Failed to parse Claude configuration:", err);
         }
       }
 
@@ -196,19 +200,5 @@ export class SSHRunner extends AgentRunner {
       }
     }
   }
-
-  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,
-      agentState: this.agentState
-    };
-  }
 }
+

package/src/lib/agents/SessionConfig.ts

@@ -0,0 +1,79 @@
+import fs from "fs";
+import path from "path";
+import { getConfigDir } from "../config";
+import crypto from "crypto";
+
+export interface SessionConfig {
+  id: string;
+  name: string;
+  type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell';
+  workspaceRoot?: string;
+  scopedDirs?: string[];
+  extraFlags?: string;
+  createdAt: string;
+}
+
+export class SessionConfigManager {
+  private static getConfigFile(): string {
+    return path.join(getConfigDir(), "configs.json");
+  }
+
+  public static loadAllConfigs(): SessionConfig[] {
+    try {
+      const file = this.getConfigFile();
+      if (!fs.existsSync(file)) {
+        return [];
+      }
+      const raw = fs.readFileSync(file, "utf8");
+      return JSON.parse(raw) || [];
+    } catch (err) {
+      console.error("[SessionConfigManager] Failed to load configs:", err);
+      return [];
+    }
+  }
+
+  public static saveConfig(config: Omit<SessionConfig, "id" | "createdAt"> & { id?: string }): SessionConfig {
+    const configs = this.loadAllConfigs();
+    const id = config.id || crypto.randomUUID();
+    const newConfig: SessionConfig = {
+      id,
+      name: config.name,
+      type: config.type,
+      workspaceRoot: config.workspaceRoot,
+      scopedDirs: config.scopedDirs,
+      extraFlags: config.extraFlags,
+      createdAt: new Date().toISOString(),
+    };
+
+    const idx = configs.findIndex(c => c.id === id);
+    if (idx !== -1) {
+      configs[idx] = newConfig;
+    } else {
+      configs.push(newConfig);
+    }
+
+    try {
+      fs.writeFileSync(this.getConfigFile(), JSON.stringify(configs, null, 2), "utf8");
+    } catch (err) {
+      console.error("[SessionConfigManager] Failed to save config to disk:", err);
+    }
+
+    return newConfig;
+  }
+
+  public static deleteConfig(id: string): boolean {
+    const configs = this.loadAllConfigs();
+    const filtered = configs.filter(c => c.id !== id);
+    if (configs.length === filtered.length) {
+      return false;
+    }
+
+    try {
+      fs.writeFileSync(this.getConfigFile(), JSON.stringify(filtered, null, 2), "utf8");
+      return true;
+    } catch (err) {
+      console.error("[SessionConfigManager] Failed to delete config from disk:", err);
+      return false;
+    }
+  }
+}

package/src/lib/agents/SessionManager.ts

@@ -33,15 +33,7 @@ export class SessionManager {
     try {
       const saved = SessionPersister.loadAllSessions();
       for (const data of saved) {
-        // Automatically clean up stopped sessions older than 24 hours to avoid clutter
-        if (data.status === "stopped") {
-          const createdTime = new Date(data.createdAt).getTime();
-          const ageHours = (Date.now() - createdTime) / (1000 * 60 * 60);
-          if (ageHours > 24) {
-            SessionPersister.deleteSession(data.id);
-            continue;
-          }
-        }
+        // Preserved persisted session
 
         let runner: AgentRunner;
         if (data.type === "mock") {
@@ -52,6 +44,8 @@ export class SessionManager {
           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 if (data.type === "shell") {
+          runner = new ShellRunner(data.id, data.name, data.workspaceRoot);
         } else {
           runner = new ClaudeRunner(data.id, data.name);
         }
@@ -73,8 +67,9 @@ export class SessionManager {
   public static getInstance(): SessionManager {
     if (!globalThis.sessionManager) {
       globalThis.sessionManager = new SessionManager();
-      // Initialize WebSocket gateway server on port 3001
-      initWebSocketServer(3001, (id) => globalThis.sessionManager!.getSession(id));
+      // Initialize WebSocket gateway server
+      const wsPort = Number(process.env.WS_PORT) || 9601;
+      initWebSocketServer(wsPort, (id) => globalThis.sessionManager!.getSession(id));
     }
     return globalThis.sessionManager;
   }
@@ -84,12 +79,15 @@ export class SessionManager {
   }
 
   public async createSession(
-    type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker',
+    type: 'mock' | 'claude' | 'claude-docker' | 'claude-ssh' | 'aider' | 'aider-docker' | 'shell',
     name?: string,
     workspaceRoot?: string,
-    scopedDirs?: string[]
+    scopedDirs?: string[],
+    parentSessionId?: string
   ): Promise<AgentRunner> {
-    const id = this.generateId();
+    const id = (type === 'shell' && parentSessionId)
+      ? `shell-${parentSessionId}-${crypto.randomUUID()}`
+      : this.generateId();
     let runner: AgentRunner;
 
     if (type === 'mock') {
@@ -100,6 +98,8 @@ export class SessionManager {
       runner = new SSHRunner(id, name);
     } else if (type === 'aider' || type === 'aider-docker') {
       runner = new AiderRunner(id, type, name);
+    } else if (type === 'shell') {
+      runner = new ShellRunner(id, name, workspaceRoot);
     } else {
       runner = new ClaudeRunner(id, name);
     }
@@ -177,10 +177,10 @@ export class SessionManager {
     }
   }
 
-  public async startSession(id: string): Promise<boolean> {
+  public async startSession(id: string, resume?: boolean): Promise<boolean> {
     const runner = this.sessions.get(id);
     if (!runner) return false;
-    await runner.start();
+    await runner.start(resume);
     SessionPersister.saveSession(runner, true);
     return true;
   }

package/src/lib/agents/SessionPersister.ts

@@ -94,16 +94,20 @@ export class SessionPersister {
       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");
+          try {
+            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);
+          } catch (fileErr) {
+            console.error(`[SessionPersister] Failed to load session file ${file}:`, fileErr);
           }
-          sessions.push(data);
         }
       }
       return sessions;