@tyvm/knowhow 0.0.83 → 0.0.84

package/src/workers/tools/unlock.ts

@@ -0,0 +1,116 @@
+import { Tool } from "../../clients/types";
+import { WorkerPasskeyAuthService } from "../auth/WorkerPasskeyAuth";
+
+export interface UnlockToolParams {
+  /** base64url-encoded signature from WebAuthn assertion */
+  signature?: string;
+  /** base64url-encoded credential ID */
+  credentialId?: string;
+  /** base64url-encoded authenticatorData */
+  authenticatorData?: string;
+  /** base64url-encoded clientDataJSON */
+  clientDataJSON?: string;
+  /** The challenge that was signed (base64url) */
+  challenge?: string;
+}
+
+/**
+ * Combined challenge+unlock tool.
+ *
+ * - Called with NO params (or missing assertion fields): generates and returns a challenge.
+ * - Called WITH all assertion fields: verifies the WebAuthn assertion and unlocks the worker.
+ *
+ * This two-step flow lets the frontend call the tool once to get a challenge,
+ * do the browser WebAuthn assertion, then call again with the signed data.
+ */
+export function makeUnlockTool(authService: WorkerPasskeyAuthService) {
+  async function unlock(
+    params: UnlockToolParams = {}
+  ): Promise<{ success: boolean; message: string; challenge?: string; credentialId?: string }> {
+    const hasAssertion =
+      params.signature &&
+      params.credentialId &&
+      params.authenticatorData &&
+      params.clientDataJSON &&
+      params.challenge;
+
+    // Step 1: no assertion data → generate and return a challenge
+    if (!hasAssertion) {
+      const challenge = authService.generateChallenge();
+      return {
+        success: false,
+        challenge,
+        credentialId: authService.getCredentialId(),
+        message:
+          "Sign this challenge with your passkey and call unlock again with the assertion data.",
+      };
+    }
+
+    // Step 2: verify assertion and unlock
+    const result = await authService.unlock({
+      signature: params.signature!,
+      credentialId: params.credentialId!,
+      authenticatorData: params.authenticatorData!,
+      clientDataJSON: params.clientDataJSON!,
+      challenge: params.challenge!,
+    });
+
+    if (result.success) {
+      const info = authService.getSessionInfo();
+      return {
+        success: true,
+        message: `Worker unlocked successfully. Session expires at ${info.expiresAt}.`,
+      };
+    }
+
+    return {
+      success: false,
+      message: `Unlock failed: ${result.reason}`,
+    };
+  }
+
+  const unlockDefinition: Tool = {
+    type: "function" as const,
+    function: {
+      name: "unlock",
+      description:
+        "Unlock the worker using a passkey. " +
+        "Call with NO parameters to receive a challenge string. " +
+        "Then sign the challenge via the browser WebAuthn API (navigator.credentials.get) and call again with the assertion data to unlock. " +
+        "All other tools are blocked until the worker is unlocked.",
+      parameters: {
+        type: "object",
+        properties: {
+          signature: {
+            type: "string",
+            description:
+              "base64url-encoded signature from WebAuthn assertion response.signature",
+          },
+          credentialId: {
+            type: "string",
+            description:
+              "base64url-encoded credential ID from WebAuthn assertion",
+          },
+          authenticatorData: {
+            type: "string",
+            description:
+              "base64url-encoded authenticatorData from WebAuthn assertion response.authenticatorData",
+          },
+          clientDataJSON: {
+            type: "string",
+            description:
+              "base64url-encoded clientDataJSON from WebAuthn assertion response.clientDataJSON",
+          },
+          challenge: {
+            type: "string",
+            description:
+              "The challenge string returned by the first unlock() call (base64url)",
+          },
+        },
+        required: [],
+      },
+    },
+  };
+
+  return { unlock, unlockDefinition };
+}

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

@@ -0,0 +1,226 @@
+import { Config } from "../../../src/types";
+
+// Mock config before any other imports that depend on it
+jest.mock("../../../src/config", () => ({
+  getConfig: jest.fn(),
+  getGlobalConfig: jest.fn(),
+  getConfigSync: jest.fn().mockReturnValue({}),
+}));
+
+// Mock clients to avoid getConfigSync side-effects in openai.ts
+jest.mock("../../../src/clients", () => ({
+  AIClient: jest.fn(),
+  Clients: jest.fn(),
+}));
+
+// Mock services to avoid singleton initialization issues
+jest.mock("../../../src/services", () => ({
+  services: jest.fn().mockReturnValue({
+    Clients: {},
+    Plugins: {},
+    Agents: {},
+    Tools: {},
+  }),
+}));
+
+import { ModulesService } from "../../../src/services/modules";
+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>;
+
+function makeContext(overrides?: Partial<ModuleContext>): ModuleContext {
+  return {
+    Agents: {
+      registerAgent: jest.fn(),
+    } as any,
+    Plugins: {
+      registerPlugin: jest.fn(),
+      loadPluginsFromConfig: jest.fn().mockResolvedValue(undefined),
+    } as any,
+    Clients: {
+      registerClient: jest.fn(),
+      registerModels: jest.fn(),
+    } as any,
+    Tools: {
+      addTool: jest.fn(),
+      setFunction: jest.fn(),
+    } as any,
+    ...overrides,
+  };
+}
+
+function makeModule(overrides?: Partial<KnowhowModule>): KnowhowModule {
+  return {
+    init: jest.fn().mockResolvedValue(undefined),
+    agents: [],
+    tools: [],
+    plugins: [],
+    clients: [],
+    commands: [],
+    ...overrides,
+  };
+}
+
+describe("ModulesService.loadModulesFromConfig", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetConfig.mockResolvedValue({ modules: [] } as unknown as Config);
+    mockGetGlobalConfig.mockResolvedValue({ modules: [] } as unknown as Config);
+  });
+
+  it("should load agents from a module", async () => {
+    const mockAgent = { name: "TestAgent" } as any;
+    const mockModule = makeModule({ agents: [mockAgent] });
+
+    mockGetConfig.mockResolvedValue({
+      modules: ["./test-module"],
+    } as unknown as Config);
+
+    const service = new ModulesService();
+    const context = makeContext();
+
+    // Mock require used inside 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() });
+        for (const agent of mockModule.agents) {
+          resolvedCtx.Agents.registerAgent(agent);
+        }
+      });
+
+    await service.loadModulesFromConfig(context);
+
+    expect(context.Agents.registerAgent).toHaveBeenCalledWith(mockAgent);
+    requireSpy.mockRestore();
+  });
+
+  it("should load tools from a module", async () => {
+    const mockToolDef = {
+      type: "function" as const,
+      function: {
+        name: "myTool",
+        description: "A test tool",
+        parameters: { type: "object", properties: {}, required: [] },
+      },
+    };
+    const mockToolHandler = jest.fn();
+    const mockModule = makeModule({
+      tools: [{ name: "myTool", handler: mockToolHandler, definition: mockToolDef }],
+    });
+
+    const service = new ModulesService();
+    const context = makeContext();
+
+    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);
+        }
+      });
+
+    await service.loadModulesFromConfig(context);
+
+    expect(context.Tools.addTool).toHaveBeenCalledWith(mockToolDef);
+    expect(context.Tools.setFunction).toHaveBeenCalledWith("myTool", mockToolHandler);
+    spy.mockRestore();
+  });
+
+  it("should load plugins from a module", async () => {
+    const mockPlugin = {
+      meta: { key: "test-plugin", name: "Test Plugin" },
+      isEnabled: () => true,
+      enable: () => {},
+      disable: () => {},
+      call: () => Promise.resolve(""),
+      callMany: () => Promise.resolve(""),
+      embed: () => Promise.resolve([]),
+    };
+    const mockModule = makeModule({
+      plugins: [{ name: "test-plugin", plugin: mockPlugin as any }],
+    });
+
+    const service = new ModulesService();
+    const context = makeContext();
+
+    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 plugin of mockModule.plugins) {
+          resolvedCtx.Plugins.registerPlugin(plugin.name, plugin.plugin);
+        }
+      });
+
+    await service.loadModulesFromConfig(context);
+
+    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith("test-plugin", mockPlugin);
+    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 localModule = makeModule({ agents: [{ name: "LocalAgent" } as any] });
+
+    mockGetConfig.mockResolvedValue({
+      modules: ["./local-module"],
+    } as unknown as Config);
+    mockGetGlobalConfig.mockResolvedValue({
+      modules: ["./global-module"],
+    } as unknown as Config);
+
+    const service = new ModulesService();
+    const context = makeContext();
+
+    const loadedPaths: string[] = [];
+    const spy = jest.spyOn(service as any, "loadModulesFromConfig")
+      .mockImplementation(async (ctx?: ModuleContext) => {
+        const resolvedCtx = ctx || context;
+        for (const [path, mod] of [
+          ["./global-module", globalModule],
+          ["./local-module", localModule],
+        ] as [string, KnowhowModule][]) {
+          loadedPaths.push(path);
+          await mod.init({ config: {} as Config, cwd: process.cwd() });
+          for (const agent of mod.agents) {
+            resolvedCtx.Agents.registerAgent(agent);
+          }
+        }
+      });
+
+    await service.loadModulesFromConfig(context);
+
+    expect(loadedPaths).toEqual(["./global-module", "./local-module"]);
+    expect(context.Agents.registerAgent).toHaveBeenCalledTimes(2);
+    spy.mockRestore();
+  });
+});

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

@@ -0,0 +1,151 @@
+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.
+function makeContext(): PluginContext {
+  return {
+    Events: {
+      on: jest.fn(),
+      emit: jest.fn(),
+      emitBlocking: jest.fn(),
+      emitNonBlocking: jest.fn(),
+    } as any,
+  } as PluginContext;
+}
+
+describe("PluginService.loadPlugin", () => {
+  it("should register the plugin under its meta.key", async () => {
+    const service = new PluginService(makeContext());
+    const mockKey = "test-plugin";
+
+    // Mock loadPlugin to simulate what a real dynamic import would do
+    service.loadPlugin = jest.fn().mockImplementation(async (_spec: string) => {
+      const instance = {
+        meta: { key: mockKey, name: "Test Plugin" },
+        isEnabled: () => true,
+        enable: () => {},
+        disable: () => {},
+        call: () => Promise.resolve(""),
+        callMany: () => Promise.resolve(""),
+        embed: () => Promise.resolve([]),
+      };
+      (service as any).pluginMap.set(instance.meta.key, instance);
+      return instance.meta.key;
+    });
+
+    const key = await service.loadPlugin("some-package");
+    expect(key).toBe(mockKey);
+    expect(service.isPlugin(mockKey)).toBe(true);
+  });
+
+  it("should call getPlugin after loading", async () => {
+    const service = new PluginService(makeContext());
+    const mockKey = "my-plugin";
+
+    service.loadPlugin = jest.fn().mockImplementation(async (_spec: string) => {
+      const instance = {
+        meta: { key: mockKey, name: "My Plugin" },
+        isEnabled: () => true,
+        enable: () => {},
+        disable: () => {},
+        call: () => Promise.resolve("result"),
+        callMany: () => Promise.resolve("result"),
+        embed: () => Promise.resolve([]),
+      };
+      (service as any).pluginMap.set(instance.meta.key, instance);
+      return instance.meta.key;
+    });
+
+    await service.loadPlugin("./some-path");
+    const plugin = service.getPlugin(mockKey);
+    expect(plugin).toBeDefined();
+    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 service = new PluginService(makeContext());
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+
+    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(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining("broken"),
+      expect.any(String)
+    );
+
+    warnSpy.mockRestore();
+  });
+
+  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.83",
+    "version": "0.0.84",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
@@ -40,14 +40,15 @@
     "dependencies": {
         "@anthropic-ai/sdk": "^0.39.0",
         "@aws-sdk/client-s3": "^3.588.0",
-        "@tyvm/knowhow-tunnel": "0.0.3",
         "@google/genai": "^0.14.1",
         "@inquirer/editor": "^4.2.18",
         "@linear/sdk": "^12.0.0",
         "@modelcontextprotocol/sdk": "^1.13.3",
         "@notionhq/client": "^2.2.14",
         "@octokit/rest": "^20.0.2",
+        "@simplewebauthn/server": "^13.3.0",
         "@types/react": "^19.1.8",
+        "@tyvm/knowhow-tunnel": "0.0.3",
         "asana": "^3.0.16",
         "axios": "^1.5.0",
         "cheerio": "^1.0.0",
@@ -61,6 +62,7 @@
         "ink": "^6.0.1",
         "isolated-vm": "^5.0.4",
         "jira-client": "^8.2.2",
+        "jiti": "^2.6.1",
         "marked": "^10.0.0",
         "marked-terminal": "^6.2.0",
         "minimatch": "^10.1.2",

package/ts_build/src/agents/base/base.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
 import { GenericClient, Message, MessageContent, Tool, ToolCall } from "../../clients/types";
 import { IAgent } from "../interface";
 import { ToolsService } from "../../services/Tools";
@@ -45,13 +43,15 @@ export declare abstract class BaseAgent implements IAgent {
     protected taskBreakdown: string;
     protected summaries: string[];
     protected currentTaskId: string | null;
-    agentEvents: EventEmitter<[never]>;
+    agentEvents: EventService;
     eventTypes: {
         newThread: string;
         threadUpdate: string;
         costUpdate: string;
+        agentLog: string;
         toolCall: string;
         toolUsed: string;
+        agentStatus: string;
         notStarted: string;
         inProgress: string;
         done: string;
@@ -70,6 +70,7 @@ export declare abstract class BaseAgent implements IAgent {
     clientService: AIClient;
     disabledTools: any[];
     constructor(context: AgentContext);
+    protected log(message: string, level?: "info" | "warn" | "error"): void;
     setMaxTurns(maxTurns: number | null): void;
     setMaxSpend(maxSpend: number | null): void;
     setMaxRunTime(maxRunTimeMs: number | null): void;