@tyvm/knowhow 0.0.108-dev.126b29e → 0.0.108-dev.80f1ac6

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/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 [

package/tests/unit/plugins/pluginLoading.test.ts

@@ -1,6 +1,5 @@
 import { PluginService } from "../../../src/plugins/plugins";
 import { PluginContext } from "../../../src/plugins/types";
-import { Config } from "../../../src/types";
 
 // Minimal mock context for PluginService construction
 // EmbeddingPlugin calls context.Events.on() in its constructor, so we must mock it.
@@ -65,87 +64,3 @@ describe("PluginService.loadPlugin", () => {
     expect(plugin!.meta.key).toBe(mockKey);
   });
 });
-
-describe("PluginService.loadPluginsFromConfig", () => {
-  it("should load plugins listed in config.pluginPackages", async () => {
-    const service = new PluginService(makeContext());
-    const loadedSpecs: string[] = [];
-
-    service.loadPlugin = jest.fn().mockImplementation(async (spec: string) => {
-      loadedSpecs.push(spec);
-      const key = `plugin-from-${spec}`;
-      const instance = {
-        meta: { key, name: key },
-        isEnabled: () => true,
-        enable: () => {},
-        disable: () => {},
-        call: () => Promise.resolve(""),
-        callMany: () => Promise.resolve(""),
-        embed: () => Promise.resolve([]),
-      };
-      (service as any).pluginMap.set(key, instance);
-      return key;
-    });
-
-    const config = {
-      pluginPackages: {
-        asana: "@knowhow/plugin-asana",
-        linear: "@knowhow/plugin-linear",
-      },
-    } as unknown as Config;
-
-    await service.loadPluginsFromConfig(config);
-
-    expect(loadedSpecs).toContain("@knowhow/plugin-asana");
-    expect(loadedSpecs).toContain("@knowhow/plugin-linear");
-    expect(loadedSpecs.length).toBe(2);
-  });
-
-  it("should handle empty pluginPackages gracefully", async () => {
-    const service = new PluginService(makeContext());
-    service.loadPlugin = jest.fn();
-
-    const config = {} as Config;
-    await expect(service.loadPluginsFromConfig(config)).resolves.toBeUndefined();
-    expect(service.loadPlugin).not.toHaveBeenCalled();
-  });
-
-  it("should log a warning and not crash when a plugin fails to load", async () => {
-    const context = makeContext();
-    const service = new PluginService(context);
-
-    service.loadPlugin = jest.fn().mockRejectedValue(new Error("Module not found"));
-
-    const config = {
-      pluginPackages: {
-        broken: "non-existent-package",
-      },
-    } as unknown as Config;
-
-    await expect(service.loadPluginsFromConfig(config)).resolves.toBeUndefined();
-    expect(context.Events.log).toHaveBeenCalledWith(
-      "PluginService",
-      expect.stringContaining("broken"),
-      "warn"
-    );
-  });
-
-  it("should load each plugin with the correct spec string", async () => {
-    const service = new PluginService(makeContext());
-    const loadedSpecs: string[] = [];
-
-    service.loadPlugin = jest.fn().mockImplementation(async (spec: string) => {
-      loadedSpecs.push(spec);
-      return spec;
-    });
-
-    const config = {
-      pluginPackages: {
-        valid: "@knowhow/valid-plugin",
-      },
-    } as unknown as Config;
-
-    await service.loadPluginsFromConfig(config);
-    expect(loadedSpecs).toEqual(["@knowhow/valid-plugin"]);
-  });
-});

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.108-dev.126b29e",
+    "version": "0.0.108-dev.80f1ac6",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
@@ -55,13 +55,12 @@
         "@inquirer/editor": "^4.2.18",
         "@modelcontextprotocol/sdk": "^1.13.3",
         "@simplewebauthn/server": "^13.3.0",
-        "@tyvm/knowhow-tunnel": "0.0.4",
+        "@tyvm/knowhow-tunnel": "0.0.5",
         "commander": "^14.0.0",
         "diff": "^5.2.0",
         "express": "^4.19.2",
         "gitignore-to-glob": "^0.3.0",
         "glob": "11.1.0",
-        "isolated-vm": "^5.0.4",
         "jiti": "^2.6.1",
         "marked": "^10.0.0",
         "marked-terminal": "^6.2.0",

package/ts_build/src/agents/base/base.js

@@ -213,6 +213,16 @@ class BaseAgent {
             if (trimmed.startsWith("✅") || /^[\d\.\-\*]/.test(trimmed))
                 return true;
         }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (parsed && typeof parsed === "object") {
+                if (typeof parsed.answer === "string")
+                    return true;
+                if (typeof parsed.finalAnswer === "string")
+                    return true;
+            }
+        }
+        catch (_) { }
         return false;
     }
     getEnabledTools() {