@tyvm/knowhow 0.0.108 → 0.0.109-dev.86123ed

package/src/workers/auth/types.ts

@@ -2,6 +2,17 @@
  * Auth message types for the worker WebSocket authentication protocol.
  */
 
+// Client → Worker: request a challenge
+export interface AuthGetChallengeMessage {
+  type: "auth:getChallenge";
+}
+
+// Worker → Client: sent when a non-auth message is received while locked
+export interface AuthLockedMessage {
+  type: "auth:locked";
+  message: string;
+}
+
 // Worker → Client: challenge
 export interface AuthChallengeMessage {
   type: "auth:challenge";
@@ -31,12 +42,13 @@ export interface AuthFailureMessage {
   type: "auth:failure";
   reason: "invalid_signature" | "expired" | "unknown_credential";
 }
-
 export type AuthMessage =
+  | AuthGetChallengeMessage
   | AuthChallengeMessage
   | AuthResponseMessage
   | AuthSuccessMessage
-  | AuthFailureMessage;
+  | AuthFailureMessage
+  | AuthLockedMessage;
 
 // Passkey credential stored in config
 export interface PasskeyCredential {

package/src/workers/tools/index.ts

@@ -2,6 +2,7 @@ export * from "./listAllowedPorts";
 export * from "./getChallenge";
 export * from "./unlock";
 export * from "./lock";
+export * from "./reloadConfig";
 
 import {
   listAllowedPorts,
@@ -11,6 +12,7 @@ import {
 export { makeGetChallengeTool } from "./getChallenge";
 export { makeUnlockTool } from "./unlock";
 export { makeLockTool } from "./lock";
+export { makeReloadConfigTool } from "./reloadConfig";
 
 export default {
   tools: { listAllowedPorts },

package/src/workers/tools/reloadConfig.ts

@@ -0,0 +1,84 @@
+import { Tool } from "../../clients/types";
+import { getConfig } from "../../config";
+import { McpServerService } from "../../services/McpServer";
+import { McpService } from "../../services/Mcp";
+import { ToolsService } from "../../services/Tools";
+
+export interface ReloadConfigResult {
+  success: boolean;
+  toolCount: number;
+  mcpCount: number;
+  message: string;
+}
+
+/**
+ * Factory that creates the reloadConfig tool with access to runtime services.
+ * The tool re-reads the config from disk, reconnects all MCPs, and rebuilds
+ * the active tool list — the same logic as the WebSocket reloadConfig handler.
+ *
+ * Typical usage after pulling updated config from the cloud worker API:
+ *   1. execCommand("knowhow cloudworker --pull <cloudWorkerId>")
+ *   2. reloadConfig()
+ */
+export function makeReloadConfigTool(
+  Mcp: McpService,
+  Tools: ToolsService,
+  mcpServer: McpServerService,
+  setToolsToUse: (tools: ReturnType<typeof Tools.getToolsByNames>) => void
+) {
+  const reloadConfig = async (): Promise<ReloadConfigResult> => {
+    try {
+      // Re-read fresh config from disk
+      const freshConfig = await getConfig();
+
+      // Close all existing MCP connections
+      await Mcp.closeAll();
+
+      // Reconnect from fresh config and re-register tools
+      await Mcp.connectToConfigured(Tools);
+
+      // Rebuild the allowed tools list from fresh config
+      const allowedToolNames =
+        freshConfig.worker?.allowedTools ?? Tools.getToolNames();
+      const newToolsToUse = Tools.getToolsByNames(allowedToolNames);
+      setToolsToUse(newToolsToUse);
+
+      // Update the MCP server with the new tool list
+      mcpServer.withTools(newToolsToUse);
+
+      const mcpCount = freshConfig.mcps?.length ?? 0;
+
+      return {
+        success: true,
+        toolCount: newToolsToUse.length,
+        mcpCount,
+        message: `Config reloaded: ${newToolsToUse.length} tools active, ${mcpCount} MCP(s) configured`,
+      };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        success: false,
+        toolCount: 0,
+        mcpCount: 0,
+        message: `Failed to reload config: ${message}`,
+      };
+    }
+  };
+
+  const reloadConfigDefinition: Tool = {
+    type: "function" as const,
+    function: {
+      name: "reloadConfig",
+      description:
+        "Reload the worker config from disk, reconnect all MCPs, and rebuild the active tool list. " +
+        "Call this after running `knowhow cloudworker --pull <id>` to apply updated MCPs without restarting the worker.",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: [],
+      },
+    },
+  };
+
+  return { reloadConfig, reloadConfigDefinition };
+}

package/tests/services/WorkerReloadConfig.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Tests for the worker reloadConfig message handler.
+ *
+ * We test the core logic in isolation — simulating the "reloadConfig" message
+ * arriving on the WebSocket and verifying that MCPs are torn down and
+ * re-connected, and that the tool list is rebuilt from fresh config.
+ */
+
+import { McpService } from "../../src/services/Mcp";
+import { ToolsService } from "../../src/services/Tools";
+
+// ---------------------------------------------------------------------------
+// Helpers: build the same reload logic that lives in worker.ts so we can
+// test it in isolation without spinning up a real WebSocket server.
+// ---------------------------------------------------------------------------
+
+async function simulateReloadConfig(
+  Mcp: McpService,
+  Tools: ToolsService,
+  mcpServer: { withTools: (tools: unknown[]) => void },
+  getConfig: () => Promise<{ worker?: { allowedTools?: string[] } }>,
+  toolsToUseRef: { value: unknown[] }
+) {
+  // This mirrors the handler in worker.ts
+  const freshConfig = await getConfig();
+  await Mcp.closeAll();
+  await Mcp.connectToConfigured(Tools);
+  const allowedToolNames =
+    freshConfig.worker?.allowedTools ?? Tools.getToolNames();
+  toolsToUseRef.value = Tools.getToolsByNames(allowedToolNames);
+  mcpServer.withTools(toolsToUseRef.value);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("Worker reloadConfig handler", () => {
+  let Mcp: McpService;
+  let Tools: ToolsService;
+  let mcpServer: { withTools: jest.Mock };
+  let toolsToUseRef: { value: unknown[] };
+
+  beforeEach(() => {
+    Mcp = new McpService();
+    Tools = new ToolsService();
+    mcpServer = { withTools: jest.fn() };
+    toolsToUseRef = { value: [] };
+
+    // Spy on MCP methods
+    jest.spyOn(Mcp, "closeAll").mockResolvedValue(undefined);
+    jest.spyOn(Mcp, "connectToConfigured").mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("should call closeAll() to tear down existing MCP connections", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: [] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(Mcp.closeAll).toHaveBeenCalledTimes(1);
+  });
+
+  it("should call connectToConfigured() to reconnect MCPs from fresh config", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: [] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(Mcp.connectToConfigured).toHaveBeenCalledWith(Tools);
+  });
+
+  it("should rebuild the tool list from allowedTools in fresh config", async () => {
+    // Spy on getToolsByNames so we can track what names were requested
+    const toolsByNamesSpy = jest
+      .spyOn(Tools, "getToolsByNames")
+      .mockReturnValue([{ function: { name: "execCommand" } }] as ReturnType<ToolsService["getToolsByNames"]>);
+
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: ["execCommand"] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(toolsByNamesSpy).toHaveBeenCalledWith(["execCommand"]);
+    expect(toolsToUseRef.value).toHaveLength(1);
+  });
+
+  it("should fall back to all tool names when allowedTools is not set", async () => {
+    const allNames = ["execCommand", "readFile", "writeFileChunk"];
+    jest.spyOn(Tools, "getToolNames").mockReturnValue(allNames);
+    const toolsByNamesSpy = jest
+      .spyOn(Tools, "getToolsByNames")
+      .mockReturnValue([] as ReturnType<ToolsService["getToolsByNames"]>);
+
+    // Config has no worker.allowedTools
+    const getConfig = jest.fn().mockResolvedValue({});
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(toolsByNamesSpy).toHaveBeenCalledWith(allNames);
+  });
+
+  it("should call mcpServer.withTools() with the rebuilt tool list", async () => {
+    const fakeTools = [{ function: { name: "readFile" } }] as ReturnType<ToolsService["getToolsByNames"]>;
+    jest.spyOn(Tools, "getToolsByNames").mockReturnValue(fakeTools);
+
+    const getConfig = jest
+      .fn()
+      .mockResolvedValue({ worker: { allowedTools: ["readFile"] } });
+
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(mcpServer.withTools).toHaveBeenCalledWith(fakeTools);
+  });
+
+  it("should re-read the config on every reload (not use stale config)", async () => {
+    const getConfig = jest
+      .fn()
+      .mockResolvedValueOnce({ worker: { allowedTools: ["execCommand"] } })
+      .mockResolvedValueOnce({ worker: { allowedTools: ["readFile", "writeFileChunk"] } });
+
+    jest.spyOn(Tools, "getToolsByNames").mockReturnValue([]);
+
+    // First reload
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+    // Second reload
+    await simulateReloadConfig(Mcp, Tools, mcpServer, getConfig, toolsToUseRef);
+
+    expect(getConfig).toHaveBeenCalledTimes(2);
+    // Each reload should tear down and reconnect
+    expect(Mcp.closeAll).toHaveBeenCalledTimes(2);
+    expect(Mcp.connectToConfigured).toHaveBeenCalledTimes(2);
+  });
+});