@tyvm/knowhow 0.0.108 → 0.0.109-dev.e88af1e

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);
+  });
+});

package/tests/unit/commands/github-credentials.test.ts

@@ -0,0 +1,211 @@
+/**
+ * Unit tests for the github-credentials command.
+ *
+ * Key invariant: running `github-credentials` must NEVER write anything other than
+ * the credential lines to stdout. Module loading logs, warnings, etc. must be
+ * silenced so the git credential helper protocol is not corrupted.
+ */
+
+// Mock config before any imports that depend on it
+jest.mock("../../../src/config", () => ({
+  getConfig: jest.fn().mockResolvedValue({ modules: [] }),
+  getGlobalConfig: jest.fn().mockResolvedValue({ modules: [] }),
+  getConfigSync: jest.fn().mockReturnValue({}),
+  migrateConfig: jest.fn().mockResolvedValue(undefined),
+}));
+
+// Mock clients to avoid openai.ts side-effects
+jest.mock("../../../src/clients", () => ({
+  AIClient: jest.fn(),
+  Clients: { registerClient: jest.fn(), registerModels: jest.fn() },
+}));
+
+// Mock KnowhowSimpleClient so we control what getGitCredential returns
+// without needing a real JWT or network connection
+jest.mock("../../../src/services/KnowhowClient", () => ({
+  KnowhowSimpleClient: jest.fn().mockImplementation(() => ({
+    getGitCredential: jest.fn().mockResolvedValue({
+      protocol: "https",
+      host: "github.com",
+      username: "x-access-token",
+      password: "ghu_TESTTOKEN123",
+    }),
+  })),
+}));
+
+// Mock readline so the 'get' action doesn't hang waiting for stdin
+jest.mock("readline", () => ({
+  createInterface: jest.fn().mockReturnValue({
+    on: jest.fn().mockImplementation(function (event: string, cb: Function) {
+      // Immediately fire 'close' so the readline promise resolves
+      if (event === "close") {
+        setImmediate(() => cb());
+      }
+      return this;
+    }),
+  }),
+}));
+
+import { Command } from "commander";
+import { addGithubCredentialsCommand } from "../../../src/commands/misc";
+import { logger } from "../../../src/logger";
+
+describe("github-credentials command", () => {
+  /**
+   * This test verifies the EARLY silencing logic in cli.ts main().
+   * The problem: modules load BEFORE parseAsync, so any module that emits
+   * warnings (e.g. Terminal module: no TunnelHandler) does so before the
+   * action's logger.silence() call can stop it.
+   *
+   * The fix: cli.ts checks process.argv before module loading and silences early.
+   * This test simulates that logic directly.
+   */
+  describe("early silencing (pre-module-load)", () => {
+    beforeEach(() => {
+      logger.unsilence();
+      logger.installConsoleOverload();
+    });
+
+    afterEach(() => {
+      logger.unsilence();
+      logger.uninstallConsoleOverload();
+    });
+
+    it("silences before module loading when github-credentials is in argv", () => {
+      const originalArgv = process.argv;
+      process.argv = ["node", "knowhow", "github-credentials", "get"];
+
+      // Simulate the exact early-detection logic from cli.ts main()
+      const rawArgs = process.argv.slice(2);
+      const SILENT_COMMANDS = ["github-credentials"];
+      if (rawArgs.some((a) => SILENT_COMMANDS.includes(a))) {
+        logger.silence();
+      }
+
+      // Now any module-load-time console.log/warn should be suppressed
+      const consoleSpy = jest.spyOn(process.stdout, "write");
+      console.warn("⚠️  Terminal module: no TunnelHandler in context — terminal addon not registered");
+      console.log("some other module loading noise");
+
+      expect(consoleSpy).not.toHaveBeenCalled();
+      consoleSpy.mockRestore();
+      process.argv = originalArgv;
+    });
+
+    it("does NOT silence for other commands", () => {
+      const originalArgv = process.argv;
+      process.argv = ["node", "knowhow", "chat"];
+
+      const rawArgs = process.argv.slice(2);
+      const SILENT_COMMANDS = ["github-credentials"];
+      if (rawArgs.some((a) => SILENT_COMMANDS.includes(a))) {
+        logger.silence();
+      }
+
+      expect(logger.isSilenced()).toBe(false);
+      process.argv = originalArgv;
+    });
+  });
+
+  let program: Command;
+  let stdoutSpy: jest.SpyInstance;
+  let writtenToStdout: string[];
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Reset logger silence state between tests
+    logger.unsilence();
+
+    // Capture process.stdout.write — this is what the credential helper uses
+    writtenToStdout = [];
+    stdoutSpy = jest
+      .spyOn(process.stdout, "write")
+      .mockImplementation((chunk: any) => {
+        writtenToStdout.push(typeof chunk === "string" ? chunk : chunk.toString());
+        return true;
+      });
+
+    program = new Command();
+    program.exitOverride(); // prevent process.exit during tests
+    addGithubCredentialsCommand(program);
+  });
+
+  afterEach(() => {
+    stdoutSpy.mockRestore();
+    logger.unsilence();
+  });
+
+  it("outputs only credential lines to stdout for 'get' action", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    expect(writtenToStdout).toHaveLength(1);
+    expect(writtenToStdout[0]).toBe(
+      "protocol=https\nhost=github.com\nusername=x-access-token\npassword=ghu_TESTTOKEN123\n"
+    );
+  });
+
+  it("silences the logger immediately so module logs don't pollute stdout", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    // The action must have called logger.silence() — state persists after action
+    expect(logger.isSilenced()).toBe(true);
+  });
+
+  it("produces exactly 4 credential field lines and nothing else", async () => {
+    await program.parseAsync([
+      "node", "knowhow", "github-credentials", "get", "--repo", "myorg/myrepo",
+    ]);
+
+    const allOutput = writtenToStdout.join("");
+    const lines = allOutput.trim().split("\n");
+
+    expect(lines).toHaveLength(4);
+    expect(lines[0]).toMatch(/^protocol=/);
+    expect(lines[1]).toMatch(/^host=/);
+    expect(lines[2]).toMatch(/^username=/);
+    expect(lines[3]).toMatch(/^password=/);
+  });
+
+  it("exits cleanly for 'store' action without writing credentials", async () => {
+    let exitCode: number | undefined;
+    // Throw to stop execution after exit() is called — otherwise the mock
+    // just sets a flag and the action continues to fetch credentials.
+    const exitSpy = jest
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        exitCode = code ?? 0;
+        throw new Error(`process.exit(${exitCode})`);
+      }) as any);
+
+    await expect(
+      program.parseAsync(["node", "knowhow", "github-credentials", "store"])
+    ).rejects.toThrow("process.exit(0)");
+
+    expect(exitCode).toBe(0);
+    expect(writtenToStdout).toHaveLength(0);
+    exitSpy.mockRestore();
+  });
+
+  it("exits cleanly for 'erase' action without writing credentials", async () => {
+    let exitCode: number | undefined;
+    const exitSpy = jest
+      .spyOn(process, "exit")
+      .mockImplementation(((code?: number) => {
+        exitCode = code ?? 0;
+        throw new Error(`process.exit(${exitCode})`);
+      }) as any);
+
+    await expect(
+      program.parseAsync(["node", "knowhow", "github-credentials", "erase"])
+    ).rejects.toThrow("process.exit(0)");
+
+    expect(exitCode).toBe(0);
+    expect(writtenToStdout).toHaveLength(0);
+    exitSpy.mockRestore();
+  });
+});

package/tests/unit/modules/moduleLoading.test.ts

@@ -24,20 +24,27 @@ jest.mock("../../../src/services", () => ({
 }));
 
 import { ModulesService } from "../../../src/services/modules";
-import { ModuleContext, KnowhowModule } from "../../../src/services/modules/types";
+import {
+  ModuleContext,
+  KnowhowModule,
+} from "../../../src/services/modules/types";
 import { getConfig, getGlobalConfig } from "../../../src/config";
 
 const mockGetConfig = getConfig as jest.MockedFunction<typeof getConfig>;
-const mockGetGlobalConfig = getGlobalConfig as jest.MockedFunction<typeof getGlobalConfig>;
+const mockGetGlobalConfig = getGlobalConfig as jest.MockedFunction<
+  typeof getGlobalConfig
+>;
 
 function makeContext(overrides?: Partial<ModuleContext>): ModuleContext {
   return {
+    Events: {
+      log: jest.fn(),
+    } as any,
     Agents: {
       registerAgent: jest.fn(),
     } as any,
     Plugins: {
       registerPlugin: jest.fn(),
-      loadPluginsFromConfig: jest.fn().mockResolvedValue(undefined),
     } as any,
     Clients: {
       registerClient: jest.fn(),
@@ -87,7 +94,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const context = makeContext();
 
     // Mock require used inside loadModulesFromConfig
-    const requireSpy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const requireSpy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
@@ -113,26 +121,35 @@ describe("ModulesService.loadModulesFromConfig", () => {
     };
     const mockToolHandler = jest.fn();
     const mockModule = makeModule({
-      tools: [{ name: "myTool", handler: mockToolHandler, definition: mockToolDef }],
+      tools: [
+        { name: "myTool", handler: mockToolHandler, definition: mockToolDef },
+      ],
     });
 
     const service = new ModulesService();
     const context = makeContext();
 
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
         for (const tool of mockModule.tools) {
           resolvedCtx.Tools.addTool(tool.definition);
-          resolvedCtx.Tools.setFunction(tool.definition.function.name, tool.handler);
+          resolvedCtx.Tools.setFunction(
+            tool.definition.function.name,
+            tool.handler
+          );
         }
       });
 
     await service.loadModulesFromConfig(context);
 
     expect(context.Tools.addTool).toHaveBeenCalledWith(mockToolDef);
-    expect(context.Tools.setFunction).toHaveBeenCalledWith("myTool", mockToolHandler);
+    expect(context.Tools.setFunction).toHaveBeenCalledWith(
+      "myTool",
+      mockToolHandler
+    );
     spy.mockRestore();
   });
 
@@ -147,7 +164,9 @@ describe("ModulesService.loadModulesFromConfig", () => {
       embed: () => Promise.resolve([]),
     };
     // ModulePlugin expects a constructor (class), not an instance
-    const MockPluginClass = jest.fn().mockImplementation(() => mockPluginInstance);
+    const MockPluginClass = jest
+      .fn()
+      .mockImplementation(() => mockPluginInstance);
     const mockModule = makeModule({
       plugins: [{ name: "test-plugin", plugin: MockPluginClass as any }],
     });
@@ -155,7 +174,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const service = new ModulesService();
     const context = makeContext();
 
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         await mockModule.init({ config: {} as Config, cwd: process.cwd() });
@@ -167,36 +187,17 @@ describe("ModulesService.loadModulesFromConfig", () => {
 
     await service.loadModulesFromConfig(context);
 
-    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith("test-plugin", mockPluginInstance);
+    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith(
+      "test-plugin",
+      mockPluginInstance
+    );
     spy.mockRestore();
   });
 
-  it("should call loadPluginsFromConfig with both global and local configs", async () => {
-    const localConfig = {
-      modules: [],
-      pluginPackages: { asana: "@knowhow/plugin-asana" },
-    } as unknown as Config;
-    const globalConfig = {
-      modules: [],
-      pluginPackages: { linear: "@knowhow/plugin-linear" },
-    } as unknown as Config;
-
-    mockGetConfig.mockResolvedValue(localConfig);
-    mockGetGlobalConfig.mockResolvedValue(globalConfig);
-
-    const service = new ModulesService();
-    const context = makeContext();
-
-    await service.loadModulesFromConfig(context);
-
-    // pluginService.loadPluginsFromConfig should be called twice: once for local, once for global
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledTimes(2);
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledWith(localConfig);
-    expect(context.Plugins.loadPluginsFromConfig).toHaveBeenCalledWith(globalConfig);
-  });
-
   it("should load modules from both global and local config paths", async () => {
-    const globalModule = makeModule({ agents: [{ name: "GlobalAgent" } as any] });
+    const globalModule = makeModule({
+      agents: [{ name: "GlobalAgent" } as any],
+    });
     const localModule = makeModule({ agents: [{ name: "LocalAgent" } as any] });
 
     mockGetConfig.mockResolvedValue({
@@ -210,7 +211,8 @@ describe("ModulesService.loadModulesFromConfig", () => {
     const context = makeContext();
 
     const loadedPaths: string[] = [];
-    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+    const spy = jest
+      .spyOn(service as any, "loadModulesFromConfig")
       .mockImplementation(async (ctx?: ModuleContext) => {
         const resolvedCtx = ctx || context;
         for (const [path, mod] of [