@tyvm/knowhow 0.0.146 → 0.0.148

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

@@ -0,0 +1,111 @@
+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, getStatus } 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"
+    );
+  });
+});
+
+describe("agents effective status", () => {
+  let previousCwd: string;
+  let tempDir: string;
+
+  beforeEach(() => {
+    previousCwd = process.cwd();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-agent-status-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(previousCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test("keeps a running status when the recorded process is alive", () => {
+    expect(getStatus("task", { status: "running", pid: process.pid })).toBe(
+      "running"
+    );
+  });
+
+  test("reports a running task as failed when its process exited", () => {
+    expect(getStatus("task", { status: "running", pid: 2_147_483_647 })).toBe(
+      "failed"
+    );
+  });
+
+  test("reports old legacy running records without a pid as stale", () => {
+    expect(
+      getStatus("task", {
+        status: "running",
+        lastUpdate: new Date(Date.now() - 10 * 60 * 1000).toISOString(),
+      })
+    ).toBe("stale");
+  });
+
+  test("never overrides a persisted terminal status", () => {
+    expect(getStatus("task", { status: "completed", pid: process.pid })).toBe(
+      "completed"
+    );
+  });
+});

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/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,53 @@
+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",
+    ]);
+  });
+
+  test("calls a registered hidden tool without making it prompt-visible", async () => {
+    const tools = new LazyToolsService();
+    tools.addTools([tool("hiddenTool")]);
+    tools.setFunction("hiddenTool", ({ value }: { value: string }) => `got:${value}`);
+
+    expect(tools.getToolNames()).not.toContain("hiddenTool");
+    expect(tools.getFunctionNames()).toContain("hiddenTool");
+
+    const result = await tools.callTool({
+      id: "hidden-call",
+      type: "function",
+      function: {
+        name: "hiddenTool",
+        arguments: JSON.stringify({ value: "test" }),
+      },
+    });
+
+    expect(result.functionResp).toBe("got:test");
+    expect(tools.getToolNames()).not.toContain("hiddenTool");
+    expect(tools.listAvailableTools()).toMatchObject({
+      disabled: expect.arrayContaining(["hiddenTool"]),
+    });
+  });
+});

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.146",
+    "version": "0.0.148",
     "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;
@@ -191,5 +192,5 @@ export declare abstract class BaseAgent implements IAgent {
         content: string;
     } | null;
     getTaskBreakdown(messages: Message[]): Promise<string>;
-    compressMessages(messages: Message[], startIndex: number, endIndex: number): Promise<Message[]>;
+    compressMessages(messages: Message[]): Promise<Message[]>;
 }