@tyvm/knowhow 0.0.145 → 0.0.147

package/tests/unit/commands/agents.test.ts

@@ -0,0 +1,68 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { Command } from "commander";
+
+const startChat = jest.fn().mockResolvedValue(undefined);
+const setupServices = jest.fn().mockResolvedValue(undefined);
+
+jest.mock("../../../src/chat", () => ({ startChat }));
+jest.mock("../../../src/commands/services", () => ({ setupServices }));
+
+import { addAgentsCommand } from "../../../src/commands/agents";
+
+describe("agents resume terminal UX", () => {
+  let previousCwd: string;
+  let tempDir: string;
+  let isTTYDescriptor: PropertyDescriptor | undefined;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    previousCwd = process.cwd();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-agents-command-"));
+    process.chdir(tempDir);
+    const taskId = "1700000000-resumable-task";
+    fs.mkdirSync(path.join(".knowhow", "processes", "agents", taskId), {
+      recursive: true,
+    });
+    fs.writeFileSync(
+      path.join(".knowhow", "processes", "agents", taskId, "metadata.json"),
+      JSON.stringify({ taskId, status: "completed", threads: [[]] })
+    );
+    isTTYDescriptor = Object.getOwnPropertyDescriptor(process.stdin, "isTTY");
+    Object.defineProperty(process.stdin, "isTTY", {
+      configurable: true,
+      value: true,
+    });
+  });
+
+  afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    if (isTTYDescriptor) {
+      Object.defineProperty(process.stdin, "isTTY", isTTYDescriptor);
+    } else {
+      delete (process.stdin as NodeJS.ReadStream & { isTTY?: boolean }).isTTY;
+    }
+  });
+
+  test("opens chat with the interactive resume command by default", async () => {
+    const program = new Command();
+    addAgentsCommand(program, jest.fn());
+
+    await program.parseAsync([
+      "node",
+      "knowhow",
+      "agents",
+      "resume",
+      "1700000000-resumable-task",
+      "--rollback",
+      "2",
+    ]);
+
+    expect(setupServices).toHaveBeenCalledTimes(1);
+    expect(startChat).toHaveBeenCalledWith(
+      "/resume 1700000000-resumable-task --rollback 2"
+    );
+  });
+});

package/tests/unit/login.test.ts

@@ -0,0 +1,119 @@
+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", () => ({ 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"), "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({ orgId: "org-1", modelProviders: [{ provider: "knowhow" }] })
+    );
+  });
+
+  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("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/plugins/pluginLoading.test.ts

@@ -1,5 +1,6 @@
 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.
@@ -63,4 +64,34 @@ describe("PluginService.loadPlugin", () => {
     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

@@ -0,0 +1,38 @@
+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);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { LazyToolsService } from "../../../src/services/LazyToolsService";
+import { Tool } from "../../../src/clients/types";
+
+function tool(name: string): Tool {
+  return {
+    type: "function",
+    function: {
+      name,
+      description: name,
+      parameters: { type: "object", properties: {}, required: [] },
+    },
+  };
+}
+
+describe("LazyToolsService persisted tool restoration", () => {
+  test("replaces pattern state with the exact saved tool list", () => {
+    const tools = new LazyToolsService();
+    tools.addTools([tool("alpha"), tool("beta"), tool("finalAnswer")]);
+    tools.enableTools(["*"]);
+    tools.disableTools(["alpha"]);
+
+    tools.restoreEnabledTools(["alpha", "finalAnswer"]);
+
+    expect(tools.getTools().map((entry) => entry.function.name).sort()).toEqual([
+      "alpha",
+      "finalAnswer",
+    ]);
+  });
+});

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

@@ -0,0 +1,29 @@
+import { RuntimeReloadService } from "../../../src/services/RuntimeReloadService";
+
+describe("RuntimeReloadService", () => {
+  it("reports when reload has not been configured", async () => {
+    await expect(new RuntimeReloadService().reload()).rejects.toThrow(
+      "Runtime reload is unavailable"
+    );
+  });
+
+  it("coalesces concurrent reload requests", async () => {
+    const service = new RuntimeReloadService();
+    let resolve!: (value: { tools: number; mcps: number; modules: number }) => void;
+    const result = { tools: 2, mcps: 1, modules: 3 };
+    const handler = jest.fn()
+      .mockImplementationOnce(() => new Promise<typeof result>((done) => (resolve = done)))
+      .mockResolvedValue(result);
+    service.configure(handler);
+
+    const first = service.reload();
+    const second = service.reload();
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(second).toBe(first);
+
+    resolve(result);
+    await expect(first).resolves.toEqual(result);
+    await service.reload();
+    expect(handler).toHaveBeenCalledTimes(2);
+  });
+});

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

@@ -0,0 +1,43 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { SessionManager } from "../../../src/services/SessionManager";
+import { TaskInfo } from "../../../src/chat/types";
+
+describe("SessionManager persisted run settings", () => {
+  let sessionsDir: string;
+
+  beforeEach(() => {
+    sessionsDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-sessions-"));
+  });
+
+  afterEach(() => {
+    fs.rmSync(sessionsDir, { recursive: true, force: true });
+  });
+
+  test("saves and updates the exact enabled tool list", () => {
+    const manager = new SessionManager(sessionsDir);
+    const taskInfo = {
+      taskId: "local-task",
+      agentName: "Patcher",
+      initialInput: "continue",
+      status: "running",
+      startTime: Date.now(),
+      totalCost: 0,
+      enabledTools: ["alpha", "finalAnswer"],
+    } as TaskInfo;
+
+    manager.saveSession(taskInfo.taskId, taskInfo, [[]]);
+    expect(manager.loadSession(taskInfo.taskId)?.enabledTools).toEqual([
+      "alpha",
+      "finalAnswer",
+    ]);
+
+    taskInfo.enabledTools = ["beta", "finalAnswer"];
+    manager.updateSession(taskInfo.taskId, taskInfo, [[]]);
+    expect(manager.loadSession(taskInfo.taskId)?.enabledTools).toEqual([
+      "beta",
+      "finalAnswer",
+    ]);
+  });
+});

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

@@ -0,0 +1,45 @@
+import { AgentSyncFs } from "../../../src/services/AgentSyncFs";
+import { SyncerService } from "../../../src/services/SyncerService";
+
+describe("SyncerService remote identity", () => {
+  beforeEach(() => {
+    jest
+      .spyOn(AgentSyncFs.prototype, "createTask")
+      .mockImplementation(async (options) => options.taskId);
+    jest
+      .spyOn(AgentSyncFs.prototype, "setRemoteIdentity")
+      .mockResolvedValue(undefined);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it("never attaches a local filesystem slug as a remote task", async () => {
+    const syncer = new SyncerService();
+    await syncer.createTask({
+      taskId: "1785905990-local-task-slug",
+      prompt: "resume",
+      syncRemote: true,
+    });
+
+    expect(syncer.getCreatedWebTaskId()).toBeUndefined();
+    expect(AgentSyncFs.prototype.setRemoteIdentity).not.toHaveBeenCalled();
+  });
+
+  it("attaches and persists an explicit remote task UUID", async () => {
+    const remoteTaskId = "123e4567-e89b-42d3-a456-426614174000";
+    const syncer = new SyncerService();
+    await syncer.createTask({
+      taskId: "1785905990-local-task-slug",
+      remoteTaskId,
+      prompt: "resume",
+      syncRemote: true,
+    });
+
+    expect(syncer.getCreatedWebTaskId()).toBe(remoteTaskId);
+    expect(AgentSyncFs.prototype.setRemoteIdentity).toHaveBeenCalledWith(
+      remoteTaskId
+    );
+  });
+});

package/tests/unit/util/Trace.test.ts

@@ -0,0 +1,119 @@
+import { Trace, TraceAll } from "../../../src/util/Trace";
+import {
+  SpanHandle,
+  TracerImpl,
+  TracingService,
+} from "../../../src/services/TracingService";
+import { ToolsService } from "../../../src/services/Tools";
+
+class TestSpan implements SpanHandle {
+  ended = false;
+  error?: unknown;
+
+  setAttribute() {}
+
+  recordError(error: unknown) {
+    this.error = error;
+  }
+
+  end() {
+    this.ended = true;
+  }
+}
+
+class TestTracer implements TracerImpl {
+  spans: Array<{
+    name: string;
+    attributes?: Record<string, string | number | boolean>;
+    span: TestSpan;
+  }> = [];
+
+  startSpan(
+    name: string,
+    attributes?: Record<string, string | number | boolean>
+  ): SpanHandle {
+    const span = new TestSpan();
+    this.spans.push({ name, attributes, span });
+    return span;
+  }
+
+  withSpan<T>(_span: SpanHandle, fn: () => T): T {
+    return fn();
+  }
+}
+
+describe("tracing decorators", () => {
+  const tracer = new TestTracer();
+
+  beforeEach(() => {
+    tracer.spans = [];
+    TracingService.register(tracer);
+  });
+
+  afterAll(() => TracingService.reset());
+
+  it("traces and closes synchronous and asynchronous methods", async () => {
+    @TraceAll()
+    class Subject {
+      sync() {
+        return "sync";
+      }
+
+      async asyncMethod() {
+        return "async";
+      }
+    }
+
+    const subject = new Subject();
+    expect(subject.sync()).toBe("sync");
+    expect(await subject.asyncMethod()).toBe("async");
+
+    expect(tracer.spans.map(({ name }) => name)).toEqual([
+      "Subject.sync",
+      "Subject.asyncMethod",
+    ]);
+    expect(tracer.spans.every(({ span }) => span.ended)).toBe(true);
+  });
+
+  it("records rejected method errors before rethrowing them", async () => {
+    const failure = new Error("failed");
+
+    class Subject {
+      @Trace()
+      async fail() {
+        throw failure;
+      }
+    }
+
+    await expect(new Subject().fail()).rejects.toBe(failure);
+    expect(tracer.spans[0].span.error).toBe(failure);
+    expect(tracer.spans[0].span.ended).toBe(true);
+  });
+
+  it("traces the concrete ToolsService.callTool path", async () => {
+    const tools = new ToolsService();
+    tools.addTool({
+      type: "function",
+      function: {
+        name: "echo",
+        description: "Echo a value",
+        parameters: {
+          type: "object",
+          properties: { value: { type: "string" } },
+          required: ["value"],
+        },
+      },
+    });
+    tools.setFunction("echo", ({ value }: { value: string }) => value);
+
+    const result = await tools.callTool({
+      id: "trace-test",
+      type: "function",
+      function: { name: "echo", arguments: JSON.stringify({ value: "ok" }) },
+    });
+
+    expect(result.functionResp).toBe("ok");
+    expect(tracer.spans.some(({ name }) => name === "ToolsService.callTool"))
+      .toBe(true);
+  });
+});

package/tests/unit/utils/http.test.ts

@@ -0,0 +1,43 @@
+import http, { HTTP_UNAUTHORIZED_HANDLER, RefreshableHeaders } from "../../../src/utils/http";
+
+describe("HTTP unauthorized renewal", () => {
+  const originalFetch = global.fetch;
+
+  afterEach(() => {
+    global.fetch = originalFetch;
+    jest.restoreAllMocks();
+  });
+
+  it("renews and retries a 401 once with the updated headers", async () => {
+    const headers: RefreshableHeaders = { Authorization: "Bearer old" };
+    const renew = jest.fn(async () => {
+      headers.Authorization = "Bearer new";
+    });
+    Object.defineProperty(headers, HTTP_UNAUTHORIZED_HANDLER, { value: renew });
+    global.fetch = jest
+      .fn()
+      .mockResolvedValueOnce(new Response("unauthorized", { status: 401 }))
+      .mockResolvedValueOnce(new Response(JSON.stringify({ ok: true }), { status: 200 }));
+
+    await expect(http.get("https://example.test", { headers })).resolves.toMatchObject({
+      data: { ok: true },
+    });
+    expect(renew).toHaveBeenCalledTimes(1);
+    expect(global.fetch).toHaveBeenNthCalledWith(
+      2,
+      "https://example.test",
+      expect.objectContaining({ headers: { Authorization: "Bearer new" } })
+    );
+  });
+
+  it("does not renew or retry a second 401", async () => {
+    const headers: RefreshableHeaders = { Authorization: "Bearer old" };
+    const renew = jest.fn(async () => undefined);
+    Object.defineProperty(headers, HTTP_UNAUTHORIZED_HANDLER, { value: renew });
+    global.fetch = jest.fn().mockResolvedValue(new Response("unauthorized", { status: 401 }));
+
+    await expect(http.get("https://example.test", { headers })).rejects.toMatchObject({ status: 401 });
+    expect(renew).toHaveBeenCalledTimes(1);
+    expect(global.fetch).toHaveBeenCalledTimes(2);
+  });
+});

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.145",
+    "version": "0.0.147",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {

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

@@ -137,6 +137,7 @@ export declare abstract class BaseAgent implements IAgent {
     protected isTerminationResponse(content: string): boolean;
     getEnabledTools(): Tool[];
     getEnabledToolNames(): string[];
+    restoreEnabledTools(names: string[]): void;
     disableTool(toolName: string): void;
     isToolEnabled(toolName: string): boolean;
     enableTool(toolName: string): void;

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

@@ -1,4 +1,13 @@
 "use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseAgent = void 0;
 const utils_1 = require("../../utils");
@@ -7,7 +16,8 @@ const clients_1 = require("../../clients");
 const ai_1 = require("../../ai");
 const MessageProcessor_1 = require("../../services/MessageProcessor");
 const contextLimits_1 = require("../../clients/contextLimits");
-class BaseAgent {
+const Trace_1 = require("../../util/Trace");
+let BaseAgent = class BaseAgent {
     status = "not_started";
     lastHealthCheckTime = 0;
     provider = "openai";
@@ -273,6 +283,21 @@ class BaseAgent {
     getEnabledToolNames() {
         return this.getEnabledTools().map((t) => t.function.name);
     }
+    restoreEnabledTools(names) {
+        const uniqueNames = [...new Set(names)];
+        const lazyTools = this.tools;
+        if (lazyTools.restoreEnabledTools) {
+            lazyTools.restoreEnabledTools(uniqueNames);
+        }
+        else {
+            lazyTools.enableTools?.(uniqueNames);
+        }
+        const savedNames = new Set(uniqueNames);
+        this.disabledTools = this.tools
+            .getTools()
+            .map((tool) => tool.function.name)
+            .filter((name) => !savedNames.has(name));
+    }
     disableTool(toolName) {
         this.disabledTools.push(toolName);
     }
@@ -1088,6 +1113,10 @@ class BaseAgent {
         this.log(`Compressed messages from ${oldLength} to ${newLength}, ${compressionRatio}% reduction in size`);
         return newMessages;
     }
-}
+};
 exports.BaseAgent = BaseAgent;
+exports.BaseAgent = BaseAgent = __decorate([
+    (0, Trace_1.TraceAll)(),
+    __metadata("design:paramtypes", [Object])
+], BaseAgent);
 //# sourceMappingURL=base.js.map