@tyvm/knowhow 0.0.104 → 0.0.106

package/src/services/AgentSyncFs.ts

@@ -121,7 +121,11 @@ export class AgentSyncFs {
   /**
    * Update metadata file with current agent state
    */
-  private async updateMetadata(agent: BaseAgent, inProgress: boolean, result?: string): Promise<void> {
+  private async updateMetadata(
+    agent: BaseAgent,
+    inProgress: boolean,
+    result?: string
+  ): Promise<void> {
     if (!this.taskPath) return;
 
     try {
@@ -137,7 +141,8 @@ export class AgentSyncFs {
 
       metadata.threads = agent.getThreads();
       metadata.totalCostUsd = agent.getTotalCostUsd();
-    metadata.agentName = agent.name;
+      metadata.tokenUsage = agent.getTokenUsage();
+      metadata.agentName = agent.name;
       metadata.inProgress = inProgress;
       metadata.lastUpdate = new Date().toISOString();
 
@@ -147,7 +152,11 @@ export class AgentSyncFs {
         await this.writeStatus("completed");
       }
 
-      await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2), "utf8");
+      await fs.writeFile(
+        metadataPath,
+        JSON.stringify(metadata, null, 2),
+        "utf8"
+      );
     } catch (error) {
       console.error(`❌ Failed to update metadata:`, error);
     }
@@ -206,7 +215,9 @@ export class AgentSyncFs {
       // Check for new input/messages
       const input = await this.readInput();
       if (input && input !== this.lastInputContent && input.trim() !== "") {
-        console.log(`📬 New message received via filesystem for task ${this.taskId}`);
+        console.log(
+          `📬 New message received via filesystem for task ${this.taskId}`
+        );
         this.lastInputContent = input;
 
         agent.addPendingUserMessage({
@@ -234,7 +245,7 @@ export class AgentSyncFs {
       await new Promise((resolve) => setTimeout(resolve, POLL_INTERVAL_MS));
 
       const status = await this.readStatus();
-      
+
       if (status === "killed") {
         console.log(`🛑 Agent task ${this.taskId} killed while paused`);
         await agent.kill();
@@ -314,7 +325,10 @@ export class AgentSyncFs {
         console.error(`❌ Error during threadUpdate sync:`, error);
       }
     };
-    agent.agentEvents.on(agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+    agent.agentEvents.on(
+      agent.eventTypes.threadUpdate,
+      this.threadUpdateHandler
+    );
 
     // Listen to completion event to finalize task (store reference for cleanup)
     this.doneHandler = (result: string) => {
@@ -323,7 +337,9 @@ export class AgentSyncFs {
         return;
       }
 
-      console.log(`🎯 [AgentSyncFs] Done event received for task: ${this.taskId}`);
+      console.log(
+        `🎯 [AgentSyncFs] Done event received for task: ${this.taskId}`
+      );
 
       // Store finalization promise so callers can await it (same pattern as AgentSyncKnowhowWeb)
       this.finalizationPromise = (async () => {
@@ -332,7 +348,9 @@ export class AgentSyncFs {
           // This prevents the race where a pending "inProgress: true" metadata write
           // overwrites the finalization write.
           if (this.pendingThreadUpdatePromise) {
-            console.log(`⏳ [AgentSyncFs] Awaiting pending thread update before finalizing...`);
+            console.log(
+              `⏳ [AgentSyncFs] Awaiting pending thread update before finalizing...`
+            );
             await this.pendingThreadUpdatePromise.catch(() => {
               // Ignore errors in pending update — we still want to finalize
             });
@@ -379,7 +397,7 @@ export class AgentSyncFs {
   private static async cleanupOldTasks(): Promise<void> {
     try {
       const agentsPath = AgentSyncFs.sharedBasePath;
-      
+
       // Check if directory exists
       try {
         await fs.access(agentsPath);
@@ -396,7 +414,7 @@ export class AgentSyncFs {
         if (!entry.isDirectory()) continue;
 
         const taskPath = path.join(agentsPath, entry.name);
-        
+
         try {
           const stats = await fs.stat(taskPath);
           const age = now - stats.mtimeMs;
@@ -449,11 +467,17 @@ export class AgentSyncFs {
     // Remove old event listeners from the agent before resetting
     if (this.agent) {
       if (this.threadUpdateHandler) {
-        this.agent.agentEvents.removeListener(this.agent.eventTypes.threadUpdate, this.threadUpdateHandler);
+        this.agent.agentEvents.removeListener(
+          this.agent.eventTypes.threadUpdate,
+          this.threadUpdateHandler
+        );
         this.threadUpdateHandler = undefined;
       }
       if (this.doneHandler) {
-        this.agent.agentEvents.removeListener(this.agent.eventTypes.done, this.doneHandler);
+        this.agent.agentEvents.removeListener(
+          this.agent.eventTypes.done,
+          this.doneHandler
+        );
         this.doneHandler = undefined;
       }
       this.agent = undefined;

package/src/services/KnowhowClient.ts

@@ -144,6 +144,17 @@ export class KnowhowSimpleClient {
     this.setJwt(jwt);
   }
 
+  /**
+   * Reload the JWT from disk (useful after login refreshes the token).
+   */
+  refreshJwt() {
+    const freshJwt = loadKnowhowJwt();
+    if (freshJwt) {
+      this.setJwt(freshJwt);
+      this.jwtValidated = false;
+    }
+  }
+
   setJwt(jwt: string) {
     this.jwt = jwt;
     this.headers = {

package/src/services/LazyToolsService.ts

@@ -57,6 +57,12 @@ export class LazyToolsService extends ToolsService {
     this.updateVisibleTools();
   }
 
+  // Override addTool (singular) to also route through allTools so that
+  // module-registered tools (via ModulesService.addTool) are tracked correctly.
+  addTool(tool: Tool) {
+    this.addTools([tool]);
+  }
+
   // Override getTools to return only enabled tools
   getTools() {
     return this.tools; // Returns filtered subset

package/src/services/S3.ts

@@ -1,5 +1,4 @@
 import * as fs from "fs";
-import * as crypto from "crypto";
 import { createWriteStream, createReadStream } from "fs";
 import { pipeline, Readable } from "stream";
 import * as util from "util";
@@ -14,17 +13,11 @@ export class S3Service {
     try {
       const fileContent = fs.readFileSync(filePath);
       const fileStats = await fs.promises.stat(filePath);
-      const sha256Base64 = crypto
-        .createHash("sha256")
-        .update(fileContent)
-        .digest("base64");
 
       const response = await fetch(presignedUrl, {
         method: "PUT",
         headers: {
           "Content-Length": String(fileStats.size),
-          "x-amz-checksum-sha256": sha256Base64,
-          "x-amz-sdk-checksum-algorithm": "SHA256",
         },
         body: fileContent,
         // @ts-ignore

package/src/services/SyncedAgentWatcher.ts

@@ -5,11 +5,6 @@
 
 import { Message } from "../clients/types";
 import { EventService } from "./EventService";
-import * as fs from "fs";
-import * as fsPromises from "fs/promises";
-import * as path from "path";
-import { messagesToRenderEvents } from "../chat/renderer/messagesToRenderEvents";
-import { KnowhowSimpleClient } from "./KnowhowClient";
 
 export interface SyncedAgentWatcher {
   /** Start watching for changes, emitting agent events */
@@ -27,7 +22,13 @@ export interface SyncedAgentWatcher {
   /** EventService that emits agent lifecycle events (toolCall, toolUsed, agentSay, threadUpdate, done) */
   agentEvents: EventService;
   /** Event type constants mirroring BaseAgent.eventTypes */
-  eventTypes: { done: string; toolCall: string; toolUsed: string; agentSay: string; threadUpdate: string };
+  eventTypes: {
+    done: string;
+    toolCall: string;
+    toolUsed: string;
+    agentSay: string;
+    threadUpdate: string;
+  };
   /** Pause the remote agent */
   pause(): Promise<void>;
   /** Unpause/resume the remote agent */
@@ -44,7 +45,12 @@ export interface SyncedAgentWatcher {
 export interface AttachableAgent {
   name: string;
   agentEvents: EventService;
-  eventTypes: { done: string; toolCall?: string; toolUsed?: string; agentSay?: string };
+  eventTypes: {
+    done: string;
+    toolCall?: string;
+    toolUsed?: string;
+    agentSay?: string;
+  };
   getTotalCostUsd(): number;
   pause(): void | Promise<void>;
   unpause(): void | Promise<void>;
@@ -104,294 +110,3 @@ export class WatcherBackedAgent implements AttachableAgent {
       });
   }
 }
-
-/**
- * Watches an agent running in another process via the filesystem.
- * Reads .knowhow/processes/agents/<taskId>/metadata.json for changes.
- * Sends messages by writing to .knowhow/processes/agents/<taskId>/input.txt
- */
-export class FsSyncedAgentWatcher implements SyncedAgentWatcher {
-  public taskId: string = "";
-  private taskPath: string = "";
-  private watcher: fs.FSWatcher | null = null;
-  private lastThreadLength: number = 0;
-  public agentName: string = "unknown";
-  private debounceTimer: NodeJS.Timeout | null = null;
-  public agentEvents = new EventService();
-  public eventTypes = {
-    done: "done",
-    toolCall: "tool:pre_call",
-    toolUsed: "tool:post_call",
-    agentSay: "agent:say",
-    threadUpdate: "thread_update",
-  };
-
-  async startWatching(taskId: string): Promise<void> {
-    this.taskId = taskId;
-    this.taskPath = path.join(".knowhow/processes/agents", taskId);
-
-    // Load initial state to track current thread length (for delta rendering)
-    const metadata = await this.readMetadata();
-    if (metadata) {
-      const threads: any[][] = metadata.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      this.agentName = metadata.agentName || taskId;
-      this.lastThreadLength = lastThread.length;
-    }
-
-    // Watch the directory for metadata.json changes
-    try {
-      this.watcher = fs.watch(this.taskPath, (event, filename) => {
-        if (filename === "metadata.json" || filename === null) {
-          // Debounce rapid file writes
-          if (this.debounceTimer) clearTimeout(this.debounceTimer);
-          this.debounceTimer = setTimeout(() => {
-            this.onMetadataChanged().catch(() => {});
-          }, 200);
-        }
-      });
-    } catch (err: any) {
-      console.warn(`⚠️  Could not watch ${this.taskPath}: ${err.message}`);
-    }
-
-    console.log(`👁️  Watching fs-synced agent: ${taskId} (${this.agentName})`);
-    console.log(
-      `   Type /logs 20 to see recent messages, or type to send a message`
-    );
-  }
-
-  private async onMetadataChanged(): Promise<void> {
-    const metadata = await this.readMetadata();
-    if (!metadata?.threads) return;
-
-    const threads: any[][] = metadata.threads;
-    const lastThread = threads[threads.length - 1] || [];
-
-    // Only render NEW messages since last check
-    const newMessages = lastThread.slice(this.lastThreadLength);
-    if (newMessages.length > 0) {
-      const renderEvents = messagesToRenderEvents(
-        newMessages,
-        this.taskId,
-        this.agentName
-      );
-      for (const event of renderEvents) {
-        if (event.type === "toolCall") {
-          this.agentEvents.emit(this.eventTypes.toolCall, {
-            toolCall: (event as any).toolCall,
-          });
-        } else if (event.type === "toolResult") {
-          this.agentEvents.emit(this.eventTypes.toolUsed, {
-            toolCall: (event as any).toolCall,
-            functionResp: (event as any).result,
-          });
-        } else if (event.type === "agentMessage") {
-          this.agentEvents.emit(this.eventTypes.agentSay, {
-            message: (event as any).message,
-          });
-        }
-      }
-      this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-      this.lastThreadLength = lastThread.length;
-    }
-
-    // Emit done if the agent has completed and has a result
-    const status = metadata.status;
-    const result = metadata.result;
-    if ((status === "completed" || status === "killed") && result != null) {
-      this.stopWatching();
-      this.agentEvents.emit(this.eventTypes.done, result);
-    }
-  }
-
-  async sendMessage(message: string): Promise<void> {
-    const inputPath = path.join(this.taskPath, "input.txt");
-    await fsPromises.writeFile(inputPath, message, "utf8");
-  }
-
-  async getThreads(): Promise<any[][]> {
-    const metadata = await this.readMetadata();
-    return metadata?.threads || [];
-  }
-
-  stopWatching(): void {
-    if (this.debounceTimer) {
-      clearTimeout(this.debounceTimer);
-      this.debounceTimer = null;
-    }
-    this.watcher?.close();
-    this.watcher = null;
-    console.log(`🔌 Stopped watching agent: ${this.taskId}`);
-  }
-
-  async pause(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "paused", "utf8");
-    console.log(`⏸️  Paused remote agent: ${this.taskId}`);
-  }
-
-  async unpause(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "running", "utf8");
-    console.log(`▶️  Unpaused remote agent: ${this.taskId}`);
-  }
-
-  async kill(): Promise<void> {
-    const statusPath = path.join(this.taskPath, "status.txt");
-    await fsPromises.writeFile(statusPath, "killed", "utf8");
-    console.log(`🛑 Killed remote agent: ${this.taskId}`);
-  }
-
-  private async readMetadata(): Promise<any> {
-    try {
-      const metaPath = path.join(this.taskPath, "metadata.json");
-      const content = await fsPromises.readFile(metaPath, "utf8");
-      return JSON.parse(content);
-    } catch {
-      return null;
-    }
-  }
-}
-
-/**
- * Watches an agent running on Knowhow Web via polling the API.
- * Polls GET /tasks/<taskId> every 3 seconds for thread updates.
- * Sends messages via the client's sendMessageToAgent method.
- */
-export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
-  public taskId: string = "";
-  private client: KnowhowSimpleClient;
-  private pollInterval: NodeJS.Timeout | null = null;
-  private lastThreadLength: number = 0;
-  public agentName: string = "remote-agent";
-  private stopped: boolean = false;
-  public agentEvents = new EventService();
-  public eventTypes = {
-    done: "done",
-    toolCall: "tool:pre_call",
-    toolUsed: "tool:post_call",
-    agentSay: "agent:say",
-    threadUpdate: "thread_update",
-  };
-
-  constructor(client?: KnowhowSimpleClient) {
-    this.client = client || new KnowhowSimpleClient();
-  }
-
-  async startWatching(taskId: string): Promise<void> {
-    this.taskId = taskId;
-    this.stopped = false;
-
-    // Load initial state to track current thread length
-    try {
-      const details = await this.client.getTaskDetails(taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      this.agentName = "remote-agent";
-      this.lastThreadLength = lastThread.length;
-    } catch (err: any) {
-      console.warn(
-        `⚠️  Could not load initial state for task ${taskId}: ${err.message}`
-      );
-    }
-
-    // Poll every 3 seconds for updates
-    this.pollInterval = setInterval(async () => {
-      if (!this.stopped) {
-        await this.onPoll().catch(() => {});
-      }
-    }, 3000);
-
-    console.log(`🌐 Watching web-synced agent: ${taskId} (${this.agentName})`);
-    console.log(
-      `   Type /logs 20 to see recent messages, or type to send a message`
-    );
-  }
-
-  private async onPoll(): Promise<void> {
-    if (this.stopped) return;
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-
-      const newMessages = lastThread.slice(this.lastThreadLength);
-      if (newMessages.length > 0) {
-        const renderEvents = messagesToRenderEvents(
-          newMessages,
-          this.taskId,
-          this.agentName
-        );
-        for (const event of renderEvents) {
-          if (event.type === "toolCall") {
-            this.agentEvents.emit(this.eventTypes.toolCall, {
-              toolCall: (event as any).toolCall,
-            });
-          } else if (event.type === "toolResult") {
-            this.agentEvents.emit(this.eventTypes.toolUsed, {
-              toolCall: (event as any).toolCall,
-              functionResp: (event as any).result,
-            });
-          } else if (event.type === "agentMessage") {
-            this.agentEvents.emit(this.eventTypes.agentSay, {
-              message: (event as any).message,
-            });
-          }
-        }
-        this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-        this.lastThreadLength = lastThread.length;
-      }
-
-      // Stop polling and emit done if task is complete with a result
-      const status = details?.data?.status;
-      const result = details?.data?.result;
-      if (status === "completed" || status === "killed") {
-        this.stopWatching();
-        if (result != null) {
-          this.agentEvents.emit(this.eventTypes.done, result);
-        } else {
-          console.log(`\n✅ Remote agent ${this.taskId} status: ${status} (no result)`);
-        }
-      }
-    } catch {
-      // Silently continue on poll errors
-    }
-  }
-
-  async sendMessage(message: string): Promise<void> {
-    await this.client.sendMessageToAgent(this.taskId, message);
-  }
-
-  async getThreads(): Promise<any[][]> {
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      return details?.data?.threads || [];
-    } catch {
-      return [];
-    }
-  }
-
-  stopWatching(): void {
-    this.stopped = true;
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    console.log(`🔌 Stopped watching web agent: ${this.taskId}`);
-  }
-
-  async pause(): Promise<void> {
-    await this.client.pauseAgent(this.taskId);
-    console.log(`⏸️  Paused remote web agent: ${this.taskId}`);
-  }
-
-  async unpause(): Promise<void> {
-    await this.client.resumeAgent(this.taskId);
-    console.log(`▶️  Unpaused remote web agent: ${this.taskId}`);
-  }
-
-  async kill(): Promise<void> {
-    await this.client.killAgent(this.taskId);
-    console.log(`🛑 Killed remote web agent: ${this.taskId}`);
-  }
-}

package/src/services/index.ts

@@ -32,6 +32,7 @@ export * from "./SessionManager";
 export * from "./TaskRegistry";
 export * from "./SyncedAgentWatcher";
 export * from "./SyncerService";
+export * from "./watchers";
 export { Clients } from "../clients";
 
 let Singletons = {} as {

package/src/services/modules/index.ts

@@ -2,7 +2,7 @@ import { getConfig, getGlobalConfig } from "../../config";
 import { KnowhowModule, ModuleContext } from "./types";
 import { ToolsService } from "../Tools";
 import { services } from "../";
-import { EventService } from "../EventService";
+import * as path from "path";
 
 export class ModulesService {
   async loadModulesFromConfig(context?: ModuleContext) {
@@ -35,8 +35,17 @@ export class ModulesService {
     ];
 
     for (const modulePath of allModulePaths) {
-      const importedModule = require(modulePath) as KnowhowModule;
+      // Resolve relative paths relative to process.cwd() so that paths like
+      // "../../packages/knowhow-module-load-webpage" in knowhow.json work
+      // regardless of where the compiled output lives.
+      const resolvedPath = modulePath.startsWith(".")
+        ? path.resolve(process.cwd(), modulePath)
+        : modulePath;
+      const rawModule = require(resolvedPath);
+      const importedModule = (rawModule.default || rawModule) as KnowhowModule;
+      console.log(`🔌 Loading module: ${modulePath} (resolved: ${resolvedPath})`);
       await importedModule.init({ config, cwd: process.cwd(), context });
+      console.log(`✅ Module initialized: ${modulePath} (tools: ${importedModule.tools.length}, agents: ${importedModule.agents.length}, plugins: ${importedModule.plugins.length}, clients: ${importedModule.clients.length})`);
 
       for (const agent of importedModule.agents) {
         agentService.registerAgent(agent);