@tyvm/knowhow 0.0.56 → 0.0.59

package/src/services/DockerService.ts

@@ -3,6 +3,7 @@ import * as path from "path";
 import * as os from "os";
 import { Config } from "../types";
 import { updateConfig } from "../config";
+import * as crypto from "crypto";
 
 export interface DockerWorkerOptions {
   workspaceDir: string;
@@ -234,15 +235,50 @@ export class DockerService {
     return { valid, errors };
   }
 
+  /**
+   * Generate a short hash from the workspace directory path
+   * This ensures one container per workspace directory
+   */
+  private getWorkspaceHash(workspaceDir: string): string {
+    const hash = crypto.createHash("md5").update(workspaceDir).digest("hex");
+    // Return first 8 characters for a short, readable hash
+    return hash.substring(0, 8);
+  }
+
+  /**
+   * Stop and remove a container by name if it exists
+   */
+  private async removeContainerByName(containerName: string): Promise<void> {
+    try {
+      // Check if container exists
+      const { stdout } = await execAsync(
+        `docker ps -a --filter "name=^/${containerName}$" --format "{{.ID}}"`
+      );
+      const containerId = stdout.trim();
+      
+      if (containerId) {
+        console.log(`🗑️  Removing existing container: ${containerName}`);
+        await execAsync(`docker stop ${containerId}`);
+        await execAsync(`docker rm ${containerId}`);
+      }
+    } catch (error) {
+      // Ignore errors if container doesn't exist
+    }
+  }
+
   /**
    * Run the knowhow worker in a Docker container
    */
   async runWorkerContainer(options: DockerWorkerOptions): Promise<string> {
-    const containerName = `${DockerService.CONTAINER_PREFIX}-${Date.now()}`;
+    const workspaceHash = this.getWorkspaceHash(options.workspaceDir);
+    const containerName = `${DockerService.CONTAINER_PREFIX}-${workspaceHash}`;
     const homedir = os.homedir();
     const relativeWorkspace = options.workspaceDir.replace(homedir, "~");
     const knowhowDir = path.join(homedir, ".knowhow");
     const relativeKnowhowDir = "~/.knowhow";
+    // Remove any existing container for this workspace
+    await this.removeContainerByName(containerName);
+
 
     let config = options.config;
 

package/src/services/EventService.ts

@@ -8,6 +8,12 @@ export interface EventHandler {
 export class EventService extends EventEmitter {
   private blockingHandlers: Map<string, EventHandler[]> = new Map();
 
+  eventTypes = {
+    agentMsg: "agent:msg",
+    agentsRegister: "agents:register",
+    agentsCall: "agents:call",
+  };
+
   constructor() {
     super();
   }
@@ -87,12 +93,12 @@ export class EventService extends EventEmitter {
   }
 
   registerAgent(agent: IAgent): void {
-    this.emit("agents:register", { name: agent.name, agent });
+    this.emit(this.eventTypes.agentsRegister, { name: agent.name, agent });
   }
 
   callAgent(name: string, query: string): Promise<string> {
     return new Promise((resolve, reject) => {
-      this.emit("agents:call", { name, query, resolve, reject });
+      this.emit(this.eventTypes.agentsCall, { name, query, resolve, reject });
     });
   }
 }

package/src/services/KnowhowClient.ts

@@ -7,7 +7,7 @@ import {
   CompletionResponse,
   EmbeddingOptions,
   EmbeddingResponse,
-} from "src/clients";
+} from "../clients";
 import { Config } from "../types";
 
 // Chat Task interfaces
@@ -33,6 +33,46 @@ export interface UpdateOrgTaskResponse {
   inProgress: boolean;
 }
 
+// Agent task synchronization interfaces
+export interface TaskDetailsResponse {
+  taskId: string;
+  inProgress: boolean;
+  status: "running" | "paused" | "killed" | "completed";
+  totalUsdCost: number;
+  threads: any;
+  createdAt: string;
+  updatedAt: string;
+  messageId?: string;
+  hasPendingMessages: boolean;
+  pendingMessagesCount: number;
+}
+
+export interface PendingMessage {
+  id: string;
+  message: string;
+  role: string;
+  createdAt: Date;
+  processedAt: Date | null;
+}
+
+export interface SendMessageRequest {
+  message: string;
+  role?: "user" | "system";
+}
+
+export interface SendMessageResponse {
+  id: string;
+  message: string;
+}
+
+export interface StatusResponse {
+  status: string;
+}
+
+export interface MarkProcessedResponse {
+  processedCount: number;
+}
+
 export function loadKnowhowJwt(): string {
   const jwtFile = path.join(process.cwd(), ".knowhow", ".jwt");
   if (!fs.existsSync(jwtFile)) {
@@ -183,4 +223,104 @@ export class KnowhowSimpleClient {
       }
     );
   }
+
+  // ============================================
+  // Agent Task Synchronization Methods
+  // ============================================
+
+  /**
+   * Get task details including status, threads, and pending message info
+   */
+  async getTaskDetails(taskId: string) {
+    await this.checkJwt();
+    return axios.get<TaskDetailsResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}`,
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Get pending messages for an agent task
+   */
+  async getPendingMessages(taskId: string) {
+    await this.checkJwt();
+    return axios.get<PendingMessage[]>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/pending-messages`,
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Mark pending messages as processed
+   */
+  async markMessagesAsProcessed(taskId: string, messageIds: string[]) {
+    await this.checkJwt();
+    return axios.post<MarkProcessedResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/pending-messages/mark-processed`,
+      { messageIds },
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Send a message to a running agent task
+   */
+  async sendMessageToAgent(taskId: string, message: string, role: "user" | "system" = "user") {
+    await this.checkJwt();
+    return axios.post<SendMessageResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/messages`,
+      { message, role },
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Pause a running agent task
+   */
+  async pauseAgent(taskId: string) {
+    await this.checkJwt();
+    return axios.post<StatusResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/pause`,
+      {},
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Resume a paused agent task
+   */
+  async resumeAgent(taskId: string) {
+    await this.checkJwt();
+    return axios.post<StatusResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/resume`,
+      {},
+      {
+        headers: this.headers,
+      }
+    );
+  }
+
+  /**
+   * Kill/cancel a running or paused agent task
+   */
+  async killAgent(taskId: string) {
+    await this.checkJwt();
+    return axios.post<StatusResponse>(
+      `${this.baseUrl}/api/org-agent-tasks/${taskId}/kill`,
+      {},
+      {
+        headers: this.headers,
+      }
+    );
+  }
 }

package/src/services/LazyToolsService.ts

@@ -0,0 +1,146 @@
+import { minimatch } from "minimatch";
+import { ToolsService, ToolContext } from "./Tools";
+import { Tool } from "../clients/types";
+import {
+  listAvailableTools,
+  enableTools,
+  disableTools,
+} from "../agents/tools/lazy";
+import { definitions } from "../agents/tools/lazy/definitions";
+
+export class LazyToolsService extends ToolsService {
+  private allTools: Tool[] = [];
+  // Start with lazy tools enabled by default
+  private enabledPatterns: string[] = [
+    "listAvailableTools",
+    "enableTools",
+    "disableTools",
+    "finalAnswer",
+  ];
+  private disabledPatterns: string[] = [];
+
+  constructor(context?: ToolContext) {
+    super(context);
+    this.registerLazyTools();
+  }
+
+  /**
+   * Registers lazy tool management tools
+   * These tools are only available when using LazyToolsService
+   */
+  private registerLazyTools(): void {
+    // Add to allTools so they're always available
+    this.allTools.push(...definitions);
+
+    // Add to visible tools so they're immediately accessible
+    super.addTools(definitions);
+
+    // Register the function implementations
+    this.addFunctions({
+      listAvailableTools: listAvailableTools.bind(this),
+      enableTools: enableTools.bind(this),
+      disableTools: disableTools.bind(this),
+    });
+  }
+
+  // Override addTools to store all tools but not expose them yet
+  addTools(tools: Tool[]) {
+    // Store tools in allTools instead of this.tools
+    const existingNames = this.allTools.map((t) => t.function.name);
+    const newTools = tools.filter(
+      (t) => !existingNames.includes(t.function.name)
+    );
+    this.allTools.push(...newTools);
+
+    // Update visible tools based on patterns
+    this.updateVisibleTools();
+  }
+
+  // Override getTools to return only enabled tools
+  getTools() {
+    return this.tools; // Returns filtered subset
+  }
+
+  // Enable tools matching glob patterns
+  enableTools(patterns: string | string[]) {
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+
+    for (const pattern of patternArray) {
+      if (!this.enabledPatterns.includes(pattern)) {
+        this.enabledPatterns.push(pattern);
+      }
+    }
+
+    this.updateVisibleTools();
+
+    return {
+      enabled: this.tools.length,
+      total: this.allTools.length,
+      patterns: this.enabledPatterns,
+    };
+  }
+
+  // Disable tools matching glob patterns
+  disableTools(patterns: string | string[]) {
+    const patternArray = Array.isArray(patterns) ? patterns : [patterns];
+
+    for (const pattern of patternArray) {
+      if (!this.disabledPatterns.includes(pattern)) {
+        this.disabledPatterns.push(pattern);
+      }
+    }
+
+    this.updateVisibleTools();
+
+    return {
+      enabled: this.tools.length,
+      total: this.allTools.length,
+      patterns: this.disabledPatterns,
+    };
+  }
+
+  // List all available tools (not just enabled ones)
+  listAvailableTools() {
+    return {
+      enabled: this.tools.map((t) => t.function.name),
+      disabled: this.allTools
+        .filter(
+          (t) => !this.tools.find((et) => et.function.name === t.function.name)
+        )
+        .map((t) => t.function.name),
+      total: this.allTools.length,
+      enabledCount: this.tools.length,
+      disabledCount: this.allTools.length - this.tools.length,
+    };
+  }
+
+  // Internal: Update visible tools based on patterns
+  private updateVisibleTools() {
+    const enabledTools: Tool[] = [];
+
+    for (const tool of this.allTools) {
+      const name = tool.function.name;
+
+      // Check if disabled by any pattern
+      const isDisabled = this.disabledPatterns.some((pattern) =>
+        minimatch(name, pattern)
+      );
+
+      if (isDisabled) {
+        continue;
+      }
+
+      // Check if enabled by any pattern (requires explicit enabling)
+      const isEnabled =
+        this.enabledPatterns.length > 0 &&
+        this.enabledPatterns.some((pattern) => minimatch(name, pattern));
+
+      if (isEnabled) {
+        enabledTools.push(tool);
+      }
+    }
+
+    // Update the visible tools array
+    this.tools = enabledTools;
+  }
+}

package/src/services/Mcp.ts

@@ -122,13 +122,175 @@ export class McpService {
 
   async connectTo(mcpServers: McpConfig[] = [], tools?: ToolsService) {
     const clients = await this.createStdioClients(mcpServers);
-    await this.connectAll();
+    await this.connectAutoServers();
 
     if (tools) {
       await this.addTools(tools);
     }
   }
 
+  // Connect only servers with autoConnect !== false
+  async connectAutoServers() {
+    await Promise.all(
+      this.clients.map(async (client, index) => {
+        const config = this.config[index];
+        const shouldAutoConnect = config.autoConnect !== false;
+
+        if (shouldAutoConnect && !this.connected[index]) {
+          console.log(`Connecting to MCP server: ${config.name}`);
+          await client.connect(this.transports[index]);
+          this.connected[index] = true;
+        } else if (!shouldAutoConnect) {
+          console.log(
+            `Skipping auto-connect for MCP server: ${config.name} (autoConnect: false)`
+          );
+        }
+      })
+    );
+  }
+
+  // Connect to a specific MCP server by name
+  async connectSingle(
+    serverName: string,
+    timeout: number = 30000
+  ): Promise<{
+    success: boolean;
+    toolsAdded: string[];
+    error?: string;
+  }> {
+    const index = this.getClientIndex(serverName);
+
+    if (index < 0) {
+      return {
+        success: false,
+        toolsAdded: [],
+        error: `MCP server '${serverName}' not found in configuration`,
+      };
+    }
+
+    if (this.connected[index]) {
+      return {
+        success: true,
+        toolsAdded: [],
+        error: `MCP server '${serverName}' already connected`,
+      };
+    }
+
+    try {
+      const client = this.clients[index];
+      const transport = this.transports[index];
+
+      // Connect with timeout
+      await Promise.race([
+        client.connect(transport),
+        new Promise((_, reject) =>
+          setTimeout(() => reject(new Error("Connection timeout")), timeout)
+        ),
+      ]);
+
+      this.connected[index] = true;
+
+      // Get tools from this server
+      const clientTools = await client.listTools();
+      const toolNames: string[] = [];
+
+      for (const tool of clientTools.tools) {
+        const transformed = this.toOpenAiTool(index, tool as any);
+        if (transformed.function.name !== tool.name) {
+          this.toolAliases[transformed.function.name] = tool.name;
+        }
+        toolNames.push(transformed.function.name);
+
+        // Add to cache if not already present
+        if (
+          !this.tools.find((t) => t.function.name === transformed.function.name)
+        ) {
+          this.tools.push(transformed);
+        }
+      }
+
+      return {
+        success: true,
+        toolsAdded: toolNames,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        toolsAdded: [],
+        error: error.message,
+      };
+    }
+  }
+
+  // Disconnect a specific MCP server
+  async disconnectSingle(serverName: string): Promise<{
+    success: boolean;
+    toolsRemoved: string[];
+    error?: string;
+  }> {
+    const index = this.getClientIndex(serverName);
+
+    if (index < 0) {
+      return {
+        success: false,
+        toolsRemoved: [],
+        error: `MCP server '${serverName}' not found`,
+      };
+    }
+
+    if (!this.connected[index]) {
+      return {
+        success: true,
+        toolsRemoved: [],
+        error: `MCP server '${serverName}' not connected`,
+      };
+    }
+
+    try {
+      const toolsToRemove = this.tools
+        .filter((t) => this.getToolClientIndex(t.function.name) === index)
+        .map((t) => t.function.name);
+
+      // Close connection
+      await this.transports[index]?.close();
+      this.connected[index] = false;
+
+      // Remove tools from cache
+      this.tools = this.tools.filter(
+        (t) => this.getToolClientIndex(t.function.name) !== index
+      );
+
+      return {
+        success: true,
+        toolsRemoved: toolsToRemove,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        toolsRemoved: [],
+        error: error.message,
+      };
+    }
+  }
+
+  // Get available servers (connected and disconnected)
+  getAvailableServers() {
+    return this.config.map((config, index) => {
+      const toolCount = this.connected[index]
+        ? this.tools.filter(
+            (t) => this.getToolClientIndex(t.function.name) === index
+          ).length
+        : 0;
+
+      return {
+        name: config.name,
+        connected: this.connected[index] || false,
+        autoConnect: config.autoConnect !== false,
+        toolCount,
+      };
+    });
+  }
+
   async addTools(tools: ToolsService) {
     tools.addTools(await this.getTools());
     tools.addFunctions(await this.getToolMap());
@@ -203,7 +365,7 @@ export class McpService {
     return this.clients[index];
   }
 
-  getFunction(toolName: string) {
+  getFunction(toolName: string, timeout?: number) {
     const client = this.getToolClient(toolName);
 
     // Handle unwrapped tool names if we have 1 client
@@ -227,8 +389,8 @@ export class McpService {
         },
         CallToolResultSchema,
         {
-          timeout: 10 * 60 * 1000,
-          maxTotalTimeout: 10 * 60 * 1000,
+          timeout: timeout || 10 * 60 * 1000,
+          maxTotalTimeout: timeout || 10 * 60 * 1000,
         }
       );
       return tool;
@@ -314,6 +476,11 @@ export class McpService {
     for (let i = 0; i < this.config.length; i++) {
       const config = this.config[i];
       const client = this.clients[i];
+
+      if (!this.connected[i]) {
+        // skip adding tools for unconnected clients
+        continue;
+      }
       const clientTools = await client.listTools();
 
       for (const tool of clientTools.tools) {