@tyvm/knowhow 0.0.83 → 0.0.85

package/src/services/AgentService.ts

@@ -7,6 +7,7 @@ import { AgentContext } from "../agents/base/base";
 
 export class AgentService {
   private agents: Map<string, IAgent> = new Map();
+  private agentContext: AgentContext | null = null;
 
   constructor(private tools: ToolsService, private events: EventService) {
     this.wireUp();
@@ -57,6 +58,22 @@ export class AgentService {
     this.agents.set(name, agent);
   }
 
+  /**
+   * Set the AgentContext that will be used when creating new agent instances.
+   * Should be called from cli.ts after all services are wired up (including LazyToolsService).
+   */
+  public setAgentContext(context: AgentContext): void {
+    this.agentContext = context;
+  }
+
+  /**
+   * Get the current AgentContext. Falls back to a minimal context using this service's
+   * own tools/events if none has been explicitly set.
+   */
+  public getAgentContext(): AgentContext {
+    return this.agentContext ?? { Tools: this.tools, Events: this.events };
+  }
+
   public getAgent(name: string): IAgent {
     const agent = this.agents.get(name);
     if (!agent) {

package/src/services/AgentSyncFs.ts

@@ -10,6 +10,7 @@ import { watch } from "fs";
 export interface FsSyncOptions {
   taskId: string;
   prompt: string;
+  agentName?: string;
 }
 
 /**
@@ -51,6 +52,7 @@ export class AgentSyncFs {
       await this.writeMetadata({
         taskId: this.taskId,
         prompt: options.prompt,
+        agentName: options.agentName || "unknown",
         startTime: new Date().toISOString(),
         status: "running",
       });
@@ -125,6 +127,7 @@ export class AgentSyncFs {
 
       metadata.threads = agent.getThreads();
       metadata.totalCostUsd = agent.getTotalCostUsd();
+    metadata.agentName = agent.name;
       metadata.inProgress = inProgress;
       metadata.lastUpdate = new Date().toISOString();
 

package/src/services/EventService.ts

@@ -1,30 +1,57 @@
 import { EventEmitter } from "events";
 import { IAgent } from "../agents/interface";
 
+export type EventHandlerFn = (...args: any[]) => any;
+
 export interface EventHandler {
-  handler: (...args: any[]) => any;
+  handler: EventHandlerFn;
+}
+
+export interface ManagedListenerSpec {
+  key: string;
+  event: string;
+  once?: boolean;
+  blocking?: boolean;
+}
+
+export interface AgentLogEvent {
+  agentName: string;
+  message: string;
+  level: "info" | "warn" | "error";
+  timestamp: number;
+  taskId?: string | null;
 }
 
+type ManagedListenerRecord = {
+  key: string;
+  event: string;
+  handler: EventHandlerFn;
+  wrappedHandler: EventHandlerFn;
+  once: boolean;
+  blocking: boolean;
+};
+
 export class EventService extends EventEmitter {
   private blockingHandlers: Map<string, EventHandler[]> = new Map();
+  private managedListeners: Map<string, ManagedListenerRecord> = new Map();
 
   eventTypes = {
     agentMsg: "agent:msg",
     agentsRegister: "agents:register",
     agentsCall: "agents:call",
+    pluginLog: "plugin:log",
   };
 
   constructor() {
     super();
+    this.setMaxListeners(100);
   }
 
   /**
-   * Register an event handler as blocking or non-blocking
-   * @param event The event name
-   * @param handler The event handler function
-   * @param isBlocking Whether this handler should be blocking
+   * Register a blocking handler.
+   * These run during emitBlocking / emitNonBlocking before normal EventEmitter listeners.
    */
-  onBlocking(event: string, handler: (...args: any[]) => any): void {
+  onBlocking(event: string, handler: EventHandlerFn): void {
     if (!this.blockingHandlers.has(event)) {
       this.blockingHandlers.set(event, []);
     }
@@ -33,10 +60,122 @@ export class EventService extends EventEmitter {
   }
 
   /**
-   * Emit a blocking event - if any blocking handler throws, execution stops
-   * @param event The event name
-   * @param args Arguments to pass to handlers
-   * @returns Promise that resolves with array of handler results when all handlers complete, or rejects if any blocking handler throws
+   * Remove a blocking handler.
+   */
+  offBlocking(event: string, handler: EventHandlerFn): void {
+    const handlers = this.blockingHandlers.get(event);
+    if (!handlers) return;
+
+    const filtered = handlers.filter((entry) => entry.handler !== handler);
+
+    if (filtered.length === 0) {
+      this.blockingHandlers.delete(event);
+      return;
+    }
+
+    this.blockingHandlers.set(event, filtered);
+  }
+
+  /**
+   * Set a managed listener.
+   *
+   * Semantics:
+   * - key is unique
+   * - if a listener already exists for this key, it is removed first
+   * - supports normal or blocking listeners
+   * - supports once semantics
+   */
+  setListener(spec: ManagedListenerSpec, handler: EventHandlerFn): void {
+    const { key, event, once = false, blocking = false } = spec;
+
+    this.removeManagedListener(key);
+
+    let wrappedHandler: EventHandlerFn;
+
+    if (once) {
+      wrappedHandler = (...args: any[]) => {
+        try {
+          handler(...args);
+        } finally {
+          this.managedListeners.delete(key);
+        }
+      };
+    } else {
+      wrappedHandler = handler;
+    }
+
+    const record: ManagedListenerRecord = {
+      key,
+      event,
+      handler,
+      wrappedHandler,
+      once,
+      blocking,
+    };
+
+    if (blocking) {
+      if (!this.blockingHandlers.has(event)) {
+        this.blockingHandlers.set(event, []);
+      }
+
+      this.blockingHandlers.get(event)!.push({ handler: wrappedHandler });
+    } else {
+      if (once) {
+        super.once(event, wrappedHandler);
+      } else {
+        super.on(event, wrappedHandler);
+      }
+    }
+
+    this.managedListeners.set(key, record);
+  }
+
+  /**
+   * Remove a managed listener by key.
+   */
+  removeManagedListener(key: string): void {
+    const existing = this.managedListeners.get(key);
+    if (!existing) return;
+
+    if (existing.blocking) {
+      this.offBlocking(existing.event, existing.wrappedHandler);
+    } else {
+      super.removeListener(existing.event, existing.wrappedHandler);
+    }
+
+    this.managedListeners.delete(key);
+  }
+
+  /**
+   * Remove all managed listeners whose key starts with the given prefix.
+   */
+  removeManagedListenersByPrefix(prefix: string): void {
+    for (const key of Array.from(this.managedListeners.keys())) {
+      if (key.startsWith(prefix)) {
+        this.removeManagedListener(key);
+      }
+    }
+  }
+
+  /**
+   * Remove all managed listeners registered through setListener.
+   */
+  clearManagedListeners(): void {
+    for (const key of Array.from(this.managedListeners.keys())) {
+      this.removeManagedListener(key);
+    }
+  }
+
+  /**
+   * Check whether a managed listener exists for the given key.
+   */
+  hasManagedListener(key: string): boolean {
+    return this.managedListeners.has(key);
+  }
+
+  /**
+   * Emit a blocking event - if any blocking handler throws, execution stops.
+   * After blocking handlers succeed, normal EventEmitter listeners are emitted.
    */
   async emitBlocking(event: string, ...args: any[]): Promise<any[]> {
     const results: any[] = [];
@@ -45,14 +184,8 @@ export class EventService extends EventEmitter {
     for (const { handler } of handlers) {
       try {
         const result = handler(...args);
-        if (result instanceof Promise) {
-          const awaitedResult = await result;
-          results.push(awaitedResult);
-        } else {
-          results.push(result);
-        }
+        results.push(result instanceof Promise ? await result : result);
       } catch (error) {
-        // If this is a blocking handler and it throws, stop execution
         throw error;
       }
     }
@@ -62,23 +195,18 @@ export class EventService extends EventEmitter {
   }
 
   /**
-   * Emit a non-blocking event - all handlers run, errors are logged but don't stop execution
-   * @param event The event name
-   * @param args Arguments to pass to handlers
-   * @returns Promise that resolves with array of handler results when all handlers complete
+   * Emit a non-blocking event - blocking handlers still run first,
+   * but their errors are logged instead of thrown.
+   * Then normal EventEmitter listeners are emitted.
    */
   async emitNonBlocking(event: string, ...args: any[]): Promise<any[]> {
     const handlers = this.blockingHandlers.get(event) || [];
     const results: any[] = [];
+
     for (const { handler } of handlers) {
       try {
         const result = handler(...args);
-        if (result instanceof Promise) {
-          const awaitedResult = await result;
-          results.push(awaitedResult);
-        } else {
-          results.push(result);
-        }
+        results.push(result instanceof Promise ? await result : result);
       } catch (error) {
         console.error(
           `Non-blocking handler error for event '${event}':`,
@@ -100,4 +228,17 @@ export class EventService extends EventEmitter {
       this.emit(this.eventTypes.agentsCall, { name, query, resolve, reject });
     });
   }
+
+  log(
+    source: string,
+    message: string,
+    level: "info" | "warn" | "error" = "info"
+  ): void {
+    this.emit(this.eventTypes.pluginLog, {
+      source,
+      message,
+      level,
+      timestamp: Date.now(),
+    });
+  }
 }

package/src/services/KnowhowClient.ts

@@ -59,6 +59,7 @@ export interface TaskDetailsResponse {
   messageId?: string;
   hasPendingMessages: boolean;
   pendingMessagesCount: number;
+  result?: string;
 }
 
 export interface PendingMessage {

package/src/services/SessionManager.ts

@@ -2,6 +2,7 @@
  * Session Manager Service - Handles agent session persistence and restoration
  */
 import * as fs from "fs";
+import * as fsPromises from "fs/promises";
 import * as path from "path";
 import { TaskInfo, ChatSession } from "../chat/types";
 
@@ -38,7 +39,9 @@ export class SessionManager {
 
     const wordPart = words.join("-") || "task";
     const epochSeconds = Math.floor(Date.now() / 1000);
-    return `${epochSeconds}-${wordPart}`;
+    const fullId = `${epochSeconds}-${wordPart}`;
+    // Truncate to 80 chars to avoid ENAMETOOLONG filesystem errors
+    return fullId.slice(0, 80);
   }
 
   /**
@@ -284,4 +287,51 @@ export class SessionManager {
 
     console.log("─".repeat(80));
   }
+
+  /**
+   * Discover agents running in other processes via the filesystem.
+   * By default only returns agents that are NOT completed/killed.
+   */
+  public async discoverFsAgents(
+    registeredIds: Set<string>,
+    includeCompleted: boolean = false
+  ): Promise<Array<{ taskId: string; agentName: string; status: string; totalCostUsd?: number }>> {
+    const agentsDir = path.join(".knowhow", "processes", "agents");
+    if (!fs.existsSync(agentsDir)) return [];
+
+    const results: Array<{ taskId: string; agentName: string; status: string; totalCostUsd?: number }> = [];
+
+    try {
+      const entries = await fsPromises.readdir(agentsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const taskId = entry.name;
+        if (registeredIds.has(taskId)) continue; // Already in-process
+        const metadataPath = path.join(agentsDir, taskId, "metadata.json");
+        try {
+          const raw = await fsPromises.readFile(metadataPath, "utf-8");
+          const metadata = JSON.parse(raw);
+          const status = metadata.status || "unknown";
+
+          // Skip completed/killed tasks unless explicitly requested
+          if (!includeCompleted && (status === "completed" || status === "killed")) {
+            continue;
+          }
+
+          results.push({
+            taskId,
+            agentName: metadata.agentName || "unknown",
+            status,
+            totalCostUsd: metadata.totalCostUsd,
+          });
+        } catch {
+          // Skip dirs without metadata
+        }
+      }
+    } catch {
+      // agentsDir not readable
+    }
+
+    return results;
+  }
 }