@tyvm/knowhow 0.0.56 → 0.0.59

package/src/services/SessionManager.ts

@@ -0,0 +1,287 @@
+/**
+ * Session Manager Service - Handles agent session persistence and restoration
+ */
+import * as fs from "fs";
+import * as path from "path";
+import { TaskInfo, ChatSession } from "../chat/types";
+
+/**
+ * SessionManager handles saving, loading, and managing agent sessions
+ */
+export class SessionManager {
+  private sessionsDir: string;
+
+  constructor(sessionsDir: string = "./.knowhow/chats/sessions") {
+    this.sessionsDir = sessionsDir;
+    this.ensureSessionsDirectoryExists();
+  }
+
+  /**
+   * Ensure the sessions directory exists
+   */
+  private ensureSessionsDirectoryExists(): void {
+    if (!fs.existsSync(this.sessionsDir)) {
+      fs.mkdirSync(this.sessionsDir, { recursive: true });
+    }
+  }
+
+  /**
+   * Generate human-readable task ID from initial input
+   */
+  generateTaskId(initialInput: string): string {
+    const words = initialInput
+      .toLowerCase()
+      .replace(/[^\w\s]/g, "")
+      .split(/\s+/)
+      .filter((word) => word.length > 2)
+      .slice(0, 9);
+
+    const wordPart = words.join("-") || "task";
+    const epochSeconds = Math.floor(Date.now() / 1000);
+    return `${epochSeconds}-${wordPart}`;
+  }
+
+  /**
+   * Save session to file
+   */
+  saveSession(taskId: string, taskInfo: TaskInfo, threads: any[]): void {
+    try {
+      const sessionPath = path.join(this.sessionsDir, `${taskId}.json`);
+      const session: ChatSession = {
+        sessionId: taskId,
+        knowhowMessageId: taskInfo.knowhowMessageId,
+        knowhowTaskId: taskInfo.knowhowTaskId,
+        taskId,
+        agentName: taskInfo.agentName,
+        initialInput: taskInfo.initialInput,
+        status: taskInfo.status,
+        startTime: taskInfo.startTime,
+        endTime: taskInfo.endTime,
+        totalCost: taskInfo.totalCost,
+        threads,
+        currentThread: 0,
+        lastUpdated: Date.now(),
+      };
+
+      fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+    } catch (error) {
+      console.error(`Error saving session ${taskId}:`, error);
+    }
+  }
+
+  /**
+   * Update existing session with new thread state
+   */
+  updateSession(
+    taskId: string,
+    taskInfo: TaskInfo | undefined,
+    threads: any[]
+  ): void {
+    try {
+      const sessionPath = path.join(this.sessionsDir, `${taskId}.json`);
+      if (fs.existsSync(sessionPath)) {
+        const session: ChatSession = JSON.parse(
+          fs.readFileSync(sessionPath, "utf8")
+        );
+
+        // Update session with current state
+        session.threads = threads;
+        session.lastUpdated = Date.now();
+
+        if (taskInfo) {
+          session.status = taskInfo.status;
+          session.endTime = taskInfo.endTime;
+          session.totalCost = taskInfo.totalCost;
+
+          // Update Knowhow task fields if they exist in TaskInfo
+          session.knowhowMessageId = taskInfo.knowhowMessageId;
+          session.knowhowTaskId = taskInfo.knowhowTaskId;
+        }
+
+        fs.writeFileSync(sessionPath, JSON.stringify(session, null, 2));
+      }
+    } catch (error) {
+      console.error(`Error updating session ${taskId}:`, error);
+    }
+  }
+
+  /**
+   * Load a session by ID
+   */
+  loadSession(sessionId: string): ChatSession | null {
+    try {
+      const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+      if (fs.existsSync(sessionPath)) {
+        const content = fs.readFileSync(sessionPath, "utf-8");
+        return JSON.parse(content) as ChatSession;
+      }
+    } catch (error) {
+      console.error(`Failed to load session ${sessionId}:`, error);
+    }
+    return null;
+  }
+
+  /**
+   * List available session files
+   */
+  listAvailableSessions(): ChatSession[] {
+    try {
+      const files = fs.readdirSync(this.sessionsDir);
+      const sessionFiles = files.filter((f) => f.endsWith(".json"));
+
+      const sessions: ChatSession[] = [];
+      const thresholdTime = 15 * 60 * 1000; // 15 minutes
+
+      for (const file of sessionFiles) {
+        const filePath = path.join(this.sessionsDir, file);
+        try {
+          const content = fs.readFileSync(filePath, "utf8");
+          const session = JSON.parse(content) as ChatSession;
+
+          // Cleanup check: mark stale running sessions as failed
+          const isStale = Date.now() - session.lastUpdated > thresholdTime;
+          const isRunning = session.status === "running";
+
+          if (isRunning && isStale) {
+            console.log(
+              `🧹 Marking stale session ${
+                session.sessionId
+              } as failed (last updated: ${new Date(
+                session.lastUpdated
+              ).toLocaleString()})`
+            );
+            session.status = "failed";
+            session.lastUpdated = Date.now();
+            // Update the session file with failed status
+            fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+          }
+
+          sessions.push(session);
+        } catch (error) {
+          console.warn(
+            `Failed to read session file ${file}:`,
+            (error as Error).message
+          );
+        }
+      }
+
+      return sessions.sort((a, b) => b.lastUpdated - a.lastUpdated);
+    } catch (error) {
+      console.warn("Failed to list sessions:", (error as Error).message);
+      return [];
+    }
+  }
+
+  /**
+   * Check if a session exists
+   */
+  sessionExists(sessionId: string): boolean {
+    const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+    return fs.existsSync(sessionPath);
+  }
+
+  /**
+   * Delete a session
+   */
+  deleteSession(sessionId: string): boolean {
+    try {
+      const sessionPath = path.join(this.sessionsDir, `${sessionId}.json`);
+      if (fs.existsSync(sessionPath)) {
+        fs.unlinkSync(sessionPath);
+        return true;
+      }
+    } catch (error) {
+      console.error(`Failed to delete session ${sessionId}:`, error);
+    }
+    return false;
+  }
+
+  async logSessionTable(
+    runningTasks: TaskInfo[],
+    savedSessions: ChatSession[]
+  ) {
+    // Display unified table
+    console.log("\n📋 Sessions & Tasks:");
+
+    const data = [];
+    // Display saved sessions first (historical)
+    savedSessions.forEach((session) => {
+      const lastUpdated = new Date(session.lastUpdated).toLocaleString();
+      const inputPreview =
+        session.initialInput && session.initialInput.length > 30
+          ? session.initialInput.substring(0, 27) + "..."
+          : session.initialInput || "[No input]";
+      const cost = session.totalCost
+        ? `$${session.totalCost.toFixed(3)}`
+        : "$0.000";
+
+      data.push({
+        ID: session.sessionId,
+        Agent: session.agentName,
+        Status: session.status,
+        Type: "saved",
+        Time: lastUpdated,
+        Cost: cost,
+        "Initial Input": inputPreview,
+      });
+    });
+
+    // Display running tasks at the bottom
+    runningTasks.forEach((task) => {
+      const elapsed = task.endTime
+        ? `${Math.round((task.endTime - task.startTime) / 1000)}s`
+        : `${Math.round((Date.now() - task.startTime) / 1000)}s`;
+      const cost = `$${task.totalCost.toFixed(3)}`;
+      const inputPreview =
+        task.initialInput.length > 30
+          ? task.initialInput.substring(0, 27) + "..."
+          : task.initialInput;
+      data.push({
+        ID: task.taskId,
+        Agent: task.agentName,
+        Status: task.status,
+        Type: "running",
+        Time: elapsed,
+        Cost: cost,
+        "Initial Input": inputPreview,
+      });
+    });
+
+    console.table(data);
+  }
+
+  async logRunningTasks(
+    runningTasks: TaskInfo[],
+    savedSessions: ChatSession[]
+  ) {
+    // Show available options for selection
+    console.log("\n📋 Available Sessions & Tasks:");
+    console.log("─".repeat(80));
+    console.log(
+      "ID".padEnd(25) + "Agent".padEnd(15) + "Status".padEnd(12) + "Type"
+    );
+    console.log("─".repeat(80));
+
+    // Show saved sessions
+    savedSessions.forEach((session) => {
+      console.log(
+        session.sessionId.padEnd(25) +
+          session.agentName.padEnd(15) +
+          session.status.padEnd(12) +
+          "saved"
+      );
+    });
+
+    // Show running tasks
+    runningTasks.forEach((task) => {
+      console.log(
+        task.taskId.padEnd(25) +
+          task.agentName.padEnd(15) +
+          task.status.padEnd(12) +
+          "running"
+      );
+    });
+
+    console.log("─".repeat(80));
+  }
+}

package/src/services/TaskRegistry.ts

@@ -0,0 +1,108 @@
+/**
+ * Task Registry Service - Manages active agent tasks
+ */
+import { TaskInfo } from "../chat/types";
+
+/**
+ * TaskRegistry manages the in-memory registry of active agent tasks
+ */
+export class TaskRegistry {
+  private tasks = new Map<string, TaskInfo>();
+
+  /**
+   * Register a new task
+   */
+  register(taskId: string, taskInfo: TaskInfo): void {
+    this.tasks.set(taskId, taskInfo);
+  }
+
+  /**
+   * Get a task by ID
+   */
+  get(taskId: string): TaskInfo | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  /**
+   * Update a task's information
+   */
+  update(taskId: string, updates: Partial<TaskInfo>): void {
+    const task = this.tasks.get(taskId);
+    if (task) {
+      Object.assign(task, updates);
+    }
+  }
+
+  /**
+   * Remove a task from the registry
+   */
+  delete(taskId: string): boolean {
+    return this.tasks.delete(taskId);
+  }
+
+  /**
+   * Check if a task exists
+   */
+  has(taskId: string): boolean {
+    return this.tasks.has(taskId);
+  }
+
+  /**
+   * Get all tasks as an array
+   */
+  getAll(): TaskInfo[] {
+    return Array.from(this.tasks.values());
+  }
+
+  /**
+   * Get all task entries
+   */
+  getEntries(): [string, TaskInfo][] {
+    return Array.from(this.tasks.entries());
+  }
+
+  /**
+   * Get the underlying Map (for compatibility)
+   */
+  getMap(): Map<string, TaskInfo> {
+    return this.tasks;
+  }
+
+  /**
+   * Clear all tasks
+   */
+  clear(): void {
+    this.tasks.clear();
+  }
+
+  /**
+   * Get count of active tasks
+   */
+  count(): number {
+    return this.tasks.size;
+  }
+
+  /**
+   * Display single task details
+   */
+  displaySingleTask(task: TaskInfo): void {
+    console.log(`\n📋 Task Details: ${task.taskId}`);
+    console.log("─".repeat(50));
+    console.log(`Agent: ${task.agentName}`);
+    console.log(`Status: ${task.status}`);
+    console.log(`Initial Input: ${task.initialInput}`);
+    console.log(`Start Time: ${new Date(task.startTime).toLocaleString()}`);
+    if (task.endTime) {
+      console.log(`End Time: ${new Date(task.endTime).toLocaleString()}`);
+      console.log(
+        `Duration: ${Math.round((task.endTime - task.startTime) / 1000)}s`
+      );
+    } else {
+      console.log(
+        `Running for: ${Math.round((Date.now() - task.startTime) / 1000)}s`
+      );
+    }
+    console.log(`Total Cost: $${task.totalCost.toFixed(3)}`);
+    console.log("─".repeat(50));
+  }
+}

package/src/services/Tools.ts

@@ -13,6 +13,7 @@ import {
   createPatternMatcher,
 } from "./types";
 import { PluginService } from "../plugins/plugins";
+import { McpService } from "./Mcp";
 
 export interface ToolContext {
   Agents?: AgentService;
@@ -20,6 +21,7 @@ export interface ToolContext {
   Clients?: AIClient;
   Tools?: ToolsService;
   Plugins?: PluginService;
+  Mcp?: McpService;
   metadata?: { [key: string]: any };
 }
 

package/src/services/index.ts

@@ -10,6 +10,9 @@ import { S3Service } from "./S3";
 import { ToolsService } from "./Tools";
 import { PluginService } from "../plugins/plugins";
 import { DockerService } from "./DockerService";
+import { AgentSynchronization } from "./AgentSynchronization";
+import { SessionManager } from "./SessionManager";
+import { TaskRegistry } from "./TaskRegistry";
 
 export * from "./AgentService";
 export * from "./EventService";
@@ -17,9 +20,13 @@ export * from "./flags";
 export * from "./GitHub";
 export * from "./S3";
 export * from "./Tools";
+export * from "./LazyToolsService";
 export * as MCP from "./Mcp";
 export * from "./EmbeddingService";
 export * from "./DockerService";
+export * from "./AgentSynchronization";
+export * from "./SessionManager";
+export * from "./TaskRegistry";
 export { Clients } from "../clients";
 
 let Singletons = {} as {

package/src/services/script-execution/ScriptExecutor.ts

@@ -55,16 +55,18 @@ export class ScriptExecutor {
       
       if (!hasNoNodeSnapshot) {
         const errorMessage = [
-          `Node.js ${nodeVersion} detected. The --no-node-snapshot flag is required for isolated-vm compatibility.`,
+          `Node.js ${nodeVersion} detected. The executeScript tool requires the --no-node-snapshot flag for isolated-vm compatibility.`,
           '',
-          'To fix this issue:',
-          '1. Restart your application with: node --no-node-snapshot your-app.js',
-          '2. Or update your package.json scripts:',
+          'This flag is automatically included when running knowhow commands via the CLI (e.g., `knowhow agent`, `knowhow chat`).',
+          '',
+          'If you are programmatically using knowhow or running custom scripts:',
+          '1. Start your application with: node --no-node-snapshot your-app.js',
+          '2. Or update your package.json scripts to include the flag:',
           '   "scripts": {',
           '     "start": "node --no-node-snapshot dist/index.js"',
           '   }',
           '',
-          'This flag is necessary for the executeScript tool to function properly with isolated-vm.'
+          'Note: This flag is required for Node.js 20+ to ensure isolated-vm works correctly.'
         ].join('\n');
         
         throw new Error(errorMessage);

package/src/types.ts

@@ -79,6 +79,7 @@ export type Assistant = {
 
 export type McpConfig = {
   name: string;
+  autoConnect?: boolean; // Default: true - connect at startup. Set to false for on-demand connection
   command?: string;
   url?: string;
   args?: string[];