@tyvm/knowhow 0.0.159 → 0.0.160

package/tests/unit/login.test.ts

@@ -1,218 +0,0 @@
-const httpGet = jest.fn();
-const browserLogin = jest.fn();
-const hasKeyPair = jest.fn();
-const authenticateWithKey = jest.fn();
-const registerPublicKey = jest.fn();
-const getOrCreatePublicKey = jest.fn();
-const getConfig = jest.fn();
-const updateConfig = jest.fn();
-
-jest.mock("../../src/utils/http", () => ({
-  __esModule: true,
-  default: { get: httpGet, isHttpError: () => false },
-}));
-
-jest.mock("../../src/services/KnowhowClient", () => ({
-  KNOWHOW_API_URL: "https://api.example",
-}));
-
-jest.mock("../../src/auth/browserLogin", () => ({
-  BrowserLoginService: jest.fn().mockImplementation(() => ({ login: browserLogin })),
-}));
-
-jest.mock("../../src/auth/keyAuth", () => ({
-  hasKeyPair,
-  authenticateWithKey,
-  registerPublicKey,
-}));
-
-jest.mock("../../src/auth/keyManager", () => ({
-  getDefaultPrivateKeyPath: () => "/keys/default",
-  getOrCreatePublicKey,
-}));
-jest.mock("../../src/config", () => ({ getConfig, updateConfig }));
-jest.mock("../../src/utils", () => ({ ask: jest.fn() }));
-
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { login } from "../../src/login";
-
-describe("login public-key bootstrap", () => {
-  const originalCwd = process.cwd();
-  let workingDirectory: string;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    jest.spyOn(console, "log").mockImplementation(() => undefined);
-    jest.spyOn(console, "warn").mockImplementation(() => undefined);
-    workingDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-login-"));
-    fs.mkdirSync(path.join(workingDirectory, ".knowhow"));
-    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.api.example"), "raw-jwt");
-    process.chdir(workingDirectory);
-    hasKeyPair.mockReturnValue(false);
-    browserLogin.mockResolvedValue(undefined);
-    getConfig.mockResolvedValue({ modelProviders: [] });
-    getOrCreatePublicKey.mockReturnValue({
-      publicKeyBase64: "raw-key",
-      fingerprint: "SHA256:key",
-    });
-    httpGet.mockResolvedValue({
-      data: {
-        orgId: "org-1",
-        user: {
-          email: "user@example.com",
-          orgs: [{ organizationId: "org-1", organization: { id: "org-1", name: "Org" } }],
-        },
-      },
-    });
-  });
-
-  afterEach(() => {
-    process.chdir(originalCwd);
-    fs.rmSync(workingDirectory, { recursive: true, force: true });
-    jest.restoreAllMocks();
-  });
-
-  it("bootstraps the selected identity after PKCE without invalidating browser login on registration failure", async () => {
-    registerPublicKey.mockRejectedValueOnce(new Error("endpoint unavailable"));
-
-    await expect(login(false, "/keys/custom")).resolves.toBeUndefined();
-
-    expect(browserLogin).toHaveBeenCalledTimes(1);
-    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/custom");
-    expect(registerPublicKey).toHaveBeenCalledWith(
-      "raw-jwt",
-      "raw-key",
-      "https://api.example"
-    );
-    expect(updateConfig).toHaveBeenCalledWith(
-      expect.objectContaining({
-        activeRemote: "api.example",
-        modelProviders: [{ provider: "knowhow" }],
-        remotes: expect.objectContaining({
-          "api.example": {
-            name: "api.example",
-            apiUrl: "https://api.example",
-            jwtPath: ".knowhow/.jwt.api.example",
-            orgId: "org-1",
-          },
-        }),
-      })
-    );
-  });
-
-  it("persists an explicit --api-url as the authenticated remote", async () => {
-    fs.writeFileSync(path.join(workingDirectory, ".knowhow", ".jwt.local"), "local-jwt");
-
-    await login(false, undefined, "http://localhost:4000/", "local");
-
-    expect(updateConfig).toHaveBeenCalledWith(
-      expect.objectContaining({
-        activeRemote: "local",
-        remotes: expect.objectContaining({
-          local: {
-            name: "local",
-            apiUrl: "http://localhost:4000",
-            jwtPath: ".knowhow/.jwt.local",
-            orgId: "org-1",
-          },
-        }),
-      })
-    );
-    expect(httpGet).toHaveBeenCalledWith(
-      "http://localhost:4000/api/users/me",
-      expect.any(Object)
-    );
-  });
-
-  it("does not persist a temporary identity path into project configuration", async () => {
-    const temporaryIdentity = path.join(os.tmpdir(), "knowhow-login-test-key");
-    getConfig.mockResolvedValue({
-      orgId: "org-1",
-      cliIdentityPath: "/tmp/knowhow-csrf-e2e-key",
-      modelProviders: [],
-    });
-    registerPublicKey.mockResolvedValueOnce(undefined);
-
-    await expect(login(false, temporaryIdentity)).resolves.toBeUndefined();
-
-    expect(getOrCreatePublicKey).toHaveBeenCalledWith(temporaryIdentity);
-    expect(updateConfig).toHaveBeenCalledTimes(1);
-    expect(updateConfig.mock.calls[0][0]).toEqual(
-      expect.not.objectContaining({
-        cliIdentityPath: expect.any(String),
-      })
-    );
-  });
-
-  it("persists the default identity selected during browser bootstrap", async () => {
-    registerPublicKey.mockResolvedValueOnce(undefined);
-
-    await expect(login(false)).resolves.toBeUndefined();
-
-    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/default");
-    expect(updateConfig).toHaveBeenCalledWith(
-      expect.objectContaining({
-        cliIdentityPath: "/keys/default",
-        modelProviders: [{ provider: "knowhow" }],
-        remotes: expect.objectContaining({ "api.example": expect.objectContaining({ orgId: "org-1" }) }),
-      })
-    );
-  });
-
-  it("safely falls back to browser PKCE when the selected key cannot authenticate", async () => {
-    hasKeyPair.mockReturnValue(true);
-    getConfig.mockResolvedValue({ orgId: "org-1", modelProviders: [] });
-    authenticateWithKey.mockRejectedValueOnce(new Error("old backend"));
-    registerPublicKey.mockResolvedValueOnce(undefined);
-
-    await expect(login(false, "/keys/dev")).resolves.toBeUndefined();
-
-    expect(authenticateWithKey).toHaveBeenCalledWith(
-      "org-1",
-      "https://api.example",
-      "/keys/dev"
-    );
-    expect(browserLogin).toHaveBeenCalledTimes(1);
-    expect(getOrCreatePublicKey).toHaveBeenCalledWith("/keys/dev");
-  });
-
-  it("uses the selected API's JWT org instead of an org saved by another environment", async () => {
-    const devJwt = `${Buffer.from("{}").toString("base64url")}.${Buffer.from(
-      JSON.stringify({ org: "org-dev" })
-    ).toString("base64url")}.signature`;
-    fs.writeFileSync(
-      path.join(workingDirectory, ".knowhow", ".jwt.api.example"),
-      devJwt
-    );
-    hasKeyPair.mockReturnValue(true);
-    getConfig.mockResolvedValue({
-      orgId: "org-local",
-      orgIds: { "http://localhost:4000": "org-local" },
-      modelProviders: [],
-    });
-    authenticateWithKey.mockResolvedValueOnce(true);
-
-    await expect(login(false, "/keys/default")).resolves.toBeUndefined();
-
-    expect(authenticateWithKey).toHaveBeenCalledWith(
-      "org-dev",
-      "https://api.example",
-      "/keys/default"
-    );
-    expect(browserLogin).not.toHaveBeenCalled();
-  });
-
-  it("does not attempt key authentication without a configured organization", async () => {
-    hasKeyPair.mockReturnValue(true);
-    getConfig.mockResolvedValue({ modelProviders: [] });
-    registerPublicKey.mockResolvedValueOnce(undefined);
-
-    await expect(login(false, "/keys/dev")).resolves.toBeUndefined();
-
-    expect(hasKeyPair).not.toHaveBeenCalled();
-    expect(authenticateWithKey).not.toHaveBeenCalled();
-    expect(browserLogin).toHaveBeenCalledTimes(1);
-  });
-});

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

@@ -1,305 +0,0 @@
-import * as os from "os";
-import * as path from "path";
-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 {
-    Events: {
-      log: jest.fn(),
-    } as any,
-    Agents: {
-      registerAgent: jest.fn(),
-    } as any,
-    Plugins: {
-      registerPlugin: jest.fn(),
-    } as any,
-    Clients: {
-      registerClient: jest.fn(),
-      registerModels: jest.fn(),
-    } as any,
-    Tools: {
-      addTool: jest.fn(),
-      setFunction: jest.fn(),
-    } as any,
-    Embeddings: {
-      registerDownloader: jest.fn(),
-      hasDownloader: jest.fn(),
-      download: 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 mockPluginInstance = {
-      meta: { key: "test-plugin", name: "Test Plugin" },
-      isEnabled: () => true,
-      enable: () => {},
-      disable: () => {},
-      call: () => Promise.resolve(""),
-      callMany: () => Promise.resolve(""),
-      embed: () => Promise.resolve([]),
-    };
-    // ModulePlugin expects a constructor (class), not an instance
-    const MockPluginClass = jest
-      .fn()
-      .mockImplementation(() => mockPluginInstance);
-    const mockModule = makeModule({
-      plugins: [{ name: "test-plugin", plugin: MockPluginClass 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) {
-          const instance = new (plugin.plugin as any)(resolvedCtx);
-          resolvedCtx.Plugins.registerPlugin(plugin.name, instance);
-        }
-      });
-
-    await service.loadModulesFromConfig(context);
-
-    expect(context.Plugins.registerPlugin).toHaveBeenCalledWith(
-      "test-plugin",
-      mockPluginInstance
-    );
-    spy.mockRestore();
-  });
-
-  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();
-  });
-
-  it("resolves global-config modules against ~/.knowhow/node_modules first, local against cwd/.knowhow/node_modules first", async () => {
-    mockGetGlobalConfig.mockResolvedValue({
-      modules: ["global-pkg"],
-    } as unknown as Config);
-    mockGetConfig.mockResolvedValue({
-      modules: ["local-pkg"],
-    } as unknown as Config);
-
-    const service = new ModulesService();
-    const context = makeContext();
-
-    const calls: { modules: string[]; resolvePaths: string[] }[] = [];
-    const spy = jest
-      .spyOn(service as any, "loadModulesFrom")
-      .mockImplementation(async (...args: any[]) => {
-        const [cfg, , resolvePaths] = args;
-        calls.push({ modules: cfg.modules, resolvePaths });
-      });
-
-    await service.loadModulesFromConfig(context);
-
-    const globalKnowhow = path.join(os.homedir(), ".knowhow", "node_modules");
-    const localKnowhow = path.join(process.cwd(), ".knowhow", "node_modules");
-
-    const globalCall = calls.find((c) => c.modules.includes("global-pkg"));
-    const localCall = calls.find((c) => c.modules.includes("local-pkg"));
-
-    expect(globalCall).toBeDefined();
-    expect(localCall).toBeDefined();
-    // Global-config module: global node_modules is first in the search order
-    expect(globalCall!.resolvePaths[0]).toBe(globalKnowhow);
-    // Local-config module: local project node_modules is first in the search order
-    expect(localCall!.resolvePaths[0]).toBe(localKnowhow);
-
-    spy.mockRestore();
-  });
-
-  it("does not load a local module again if it is already declared globally (avoids duplicate command registration)", async () => {
-    mockGetGlobalConfig.mockResolvedValue({
-      modules: ["shared-pkg"],
-    } as unknown as Config);
-    mockGetConfig.mockResolvedValue({
-      modules: ["shared-pkg", "local-only-pkg"],
-    } as unknown as Config);
-
-    const service = new ModulesService();
-    const context = makeContext();
-
-    const loadedModuleLists: string[][] = [];
-    const spy = jest
-      .spyOn(service as any, "loadModulesFrom")
-      .mockImplementation(async (...args: any[]) => {
-        const [cfg] = args;
-        loadedModuleLists.push(cfg.modules);
-      });
-
-    await service.loadModulesFromConfig(context);
-
-    const allLoaded = loadedModuleLists.flat();
-    // shared-pkg loaded exactly once (via the global pass)
-    expect(allLoaded.filter((m) => m === "shared-pkg")).toHaveLength(1);
-    // local-only-pkg still loaded
-    expect(allLoaded).toContain("local-only-pkg");
-
-    spy.mockRestore();
-  });
-});

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

@@ -1,97 +0,0 @@
-import { PluginService } from "../../../src/plugins/plugins";
-import { PluginContext } from "../../../src/plugins/types";
-import * as configModule from "../../../src/config";
-
-// 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(),
-      log: 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);
-  });
-
-  it("applies disabled plugins from config and re-enables removed entries", async () => {
-    const service = new PluginService(makeContext());
-    const plugin = {
-      meta: { key: "git", name: "Git Plugin" },
-      isEnabled: jest.fn(() => true),
-      enable: jest.fn(),
-      disable: jest.fn(),
-      call: jest.fn(async () => ""),
-      callMany: jest.fn(async () => ""),
-    };
-    service.registerPlugin("git", plugin);
-
-    const configSpy = jest.spyOn(configModule, "getConfig");
-    configSpy.mockResolvedValueOnce({
-      plugins: { enabled: [], disabled: ["git"] },
-    } as any);
-    await service.refreshConfiguredState();
-
-    expect(plugin.disable).toHaveBeenCalledTimes(1);
-    expect(plugin.enable).not.toHaveBeenCalled();
-
-    configSpy.mockResolvedValueOnce({
-      plugins: { enabled: ["git"], disabled: [] },
-    } as any);
-    await service.refreshConfiguredState();
-
-    expect(plugin.enable).toHaveBeenCalledTimes(1);
-    configSpy.mockRestore();
-  });
-});

package/tests/unit/services/AgentSyncKnowhowWeb.test.ts

@@ -1,38 +0,0 @@
-import { AgentSyncKnowhowWeb } from "../../../src/services/AgentSyncKnowhowWeb";
-
-describe("AgentSyncKnowhowWeb sync error reporting", () => {
-  let errorSpy: jest.SpyInstance;
-
-  beforeEach(() => {
-    errorSpy = jest.spyOn(console, "error").mockImplementation(() => undefined);
-  });
-
-  afterEach(() => {
-    errorSpy.mockRestore();
-  });
-
-  it("reports only the first remote failure for a task", async () => {
-    const sync = new AgentSyncKnowhowWeb();
-    (sync as any).client = {
-      createChatTask: jest.fn().mockRejectedValue(new Error("offline")),
-    };
-
-    await sync.createChatTask({ messageId: "message-1", prompt: "test" });
-    await sync.createChatTask({ messageId: "message-1", prompt: "test" });
-
-    expect(errorSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it("allows the next task to report its first failure after reset", async () => {
-    const sync = new AgentSyncKnowhowWeb();
-    (sync as any).client = {
-      createChatTask: jest.fn().mockRejectedValue(new Error("offline")),
-    };
-
-    await sync.createChatTask({ messageId: "message-1", prompt: "test" });
-    sync.reset();
-    await sync.createChatTask({ messageId: "message-2", prompt: "test" });
-
-    expect(errorSpy).toHaveBeenCalledTimes(2);
-  });
-});