@tyvm/knowhow 0.0.154 → 0.0.156

package/tests/unit/agents/tools/loadImageAsBase64.test.ts

@@ -0,0 +1,44 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  loadImageAsBase64,
+  loadImageAsBase64Definition,
+} from "../../../../src/agents/tools/loadImageAsBase64";
+import { Base64ImageProcessor } from "../../../../src/processors/Base64ImageDetector";
+import { ToolsService } from "../../../../src/services/Tools";
+
+describe("loadImageAsBase64 tool", () => {
+  it("returns an image data URL with a MIME type detected from its bytes", async () => {
+    const directory = await fs.promises.mkdtemp(path.join(os.tmpdir(), "knowhow-image-"));
+    const filePath = path.join(directory, "incorrectly-named.jpg");
+
+    try {
+      await fs.promises.writeFile(filePath, Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]));
+      const result = JSON.parse(await loadImageAsBase64(filePath));
+
+      expect(result).toMatchObject({
+        type: "image_url",
+        image_url: { detail: "auto" },
+      });
+      expect(result.image_url.url).toMatch(/^data:image\/png;base64,/);
+    } finally {
+      await fs.promises.rm(directory, { recursive: true, force: true });
+    }
+  });
+
+  it("can also be registered by the image message processor without duplication", () => {
+    const toolsService = new ToolsService();
+    toolsService.defineTools(
+      [loadImageAsBase64Definition],
+      { loadImageAsBase64 }
+    );
+
+    new Base64ImageProcessor(toolsService);
+
+    expect(
+      toolsService.getToolNames().filter((name) => name === "loadImageAsBase64")
+    ).toHaveLength(1);
+    expect(typeof toolsService.getFunction("loadImageAsBase64")).toBe("function");
+  });
+});

package/tests/unit/auth/keyAuth.test.ts

@@ -14,6 +14,7 @@ jest.mock("../../../src/utils/http", () => ({
 }));
 
 jest.mock("../../../src/auth/keyManager", () => ({
+  getDefaultPrivateKeyPath: () => "/keys/default",
   keyPairExists,
   loadKeyPair,
   signMessage,
@@ -23,11 +24,16 @@ jest.mock("../../../src/auth/browserLogin", () => ({
   getCliUserAgent: () => "test-agent",
 }));
 
+import fs from "fs";
+import os from "os";
+import path from "path";
 import {
   authenticateWithKey,
+  exchangeAvailablePublicKeyJwt,
   exchangePublicKeyJwt,
   hasKeyPair,
   registerPublicKey,
+  storeJwt,
 } from "../../../src/auth/keyAuth";
 
 describe("keyAuth", () => {
@@ -69,17 +75,61 @@ describe("keyAuth", () => {
     ]);
   });
 
+  it("uses the registered default identity when a configured identity is rejected", async () => {
+    post
+      .mockRejectedValueOnce({ status: 401 })
+      .mockResolvedValueOnce({
+        data: {
+          challengeId: "challenge_2",
+          message: "default key challenge",
+          expiresAt: "2099-01-01T00:00:00.000Z",
+        },
+        status: 201,
+      })
+      .mockResolvedValueOnce({ data: { jwt: "default-key-jwt" }, status: 200 });
+
+    await expect(
+      exchangeAvailablePublicKeyJwt("org-1", "https://work.example", "/keys/stale")
+    ).resolves.toBe("default-key-jwt");
+
+    expect(loadKeyPair.mock.calls).toEqual([
+      ["/keys/stale"],
+      ["/keys/default"],
+    ]);
+    expect(signMessage).toHaveBeenCalledWith(
+      "default key challenge",
+      "/keys/default"
+    );
+  });
+
   it("falls back when the key is unavailable without signing a challenge", async () => {
-    post.mockRejectedValueOnce({ status: 401 });
+    post.mockRejectedValue({ status: 401 });
 
     await expect(
       authenticateWithKey("org-1", "https://work.example", "/keys/work")
     ).resolves.toBe(false);
 
-    expect(post).toHaveBeenCalledTimes(1);
+    expect(post).toHaveBeenCalledTimes(2);
     expect(signMessage).not.toHaveBeenCalled();
   });
 
+  it("stores a refreshed JWT in the active isolated project", () => {
+    const originalCwd = process.cwd();
+    const temporaryProject = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-key-auth-"));
+    try {
+      process.chdir(temporaryProject);
+
+      storeJwt("fresh-project-jwt");
+
+      const jwtPath = path.join(temporaryProject, ".knowhow", ".jwt");
+      expect(fs.readFileSync(jwtPath, "utf8")).toBe("fresh-project-jwt");
+      expect(fs.statSync(jwtPath).mode & 0o777).toBe(0o600);
+    } finally {
+      process.chdir(originalCwd);
+      fs.rmSync(temporaryProject, { recursive: true, force: true });
+    }
+  });
+
   it("registers only server-owned Ed25519 key fields in the selected environment", async () => {
     post.mockResolvedValueOnce({ data: {}, status: 201 });
 

package/tests/unit/login.test.ts

@@ -26,7 +26,10 @@ jest.mock("../../src/auth/keyAuth", () => ({
   registerPublicKey,
 }));
 
-jest.mock("../../src/auth/keyManager", () => ({ getOrCreatePublicKey }));
+jest.mock("../../src/auth/keyManager", () => ({
+  getDefaultPrivateKeyPath: () => "/keys/default",
+  getOrCreatePublicKey,
+}));
 jest.mock("../../src/config", () => ({ getConfig, updateConfig }));
 jest.mock("../../src/utils", () => ({ ask: jest.fn() }));
 
@@ -88,6 +91,41 @@ describe("login public-key bootstrap", () => {
     );
   });
 
+  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({
+        orgId: "org-1",
+        cliIdentityPath: "/keys/default",
+        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: [] });

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

@@ -0,0 +1,84 @@
+import fs from "fs";
+
+const mockGet = jest.fn();
+const mockExchangePublicKeyJwt = jest.fn();
+const mockStoreJwt = jest.fn();
+
+jest.mock("../../../src/utils/http", () => {
+  const actual = jest.requireActual("../../../src/utils/http");
+  const mockedHttp = {
+    get: (...args: unknown[]) => mockGet(...args),
+  };
+  return {
+    __esModule: true,
+    ...actual,
+    http: mockedHttp,
+    default: mockedHttp,
+  };
+});
+
+jest.mock("../../../src/config", () => ({
+  getConfigSync: jest.fn().mockReturnValue({
+    orgId: "org-1",
+    cliIdentityPath: "/tmp/identity",
+  }),
+}));
+
+jest.mock("../../../src/auth/keyManager", () => ({
+  keyPairExists: jest.fn().mockReturnValue(true),
+}));
+
+jest.mock("../../../src/auth/keyAuth", () => ({
+  exchangeAvailablePublicKeyJwt: (...args: unknown[]) => mockExchangePublicKeyJwt(...args),
+  storeJwt: (...args: unknown[]) => mockStoreJwt(...args),
+}));
+
+import { KnowhowSimpleClient } from "../../../src/services/KnowhowClient";
+
+describe("KnowhowSimpleClient identity renewal", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+    jest.clearAllMocks();
+  });
+
+  it("obtains a JWT from the registered identity before loading models when no JWT exists", async () => {
+    jest.spyOn(fs, "existsSync").mockReturnValue(false);
+    mockExchangePublicKeyJwt.mockResolvedValue("fresh-jwt");
+    mockGet.mockResolvedValueOnce({ data: { data: [] } });
+
+    const client = new KnowhowSimpleClient("https://api.example.test");
+    await client.getModels();
+
+    expect(mockExchangePublicKeyJwt).toHaveBeenCalledWith(
+      "org-1",
+      "https://api.example.test",
+      "/tmp/identity"
+    );
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
+  });
+
+  it("replaces an expired JWT with one signed by the registered identity before loading models", async () => {
+    const expiredJwt = [
+      Buffer.from('{"alg":"none"}').toString("base64url"),
+      Buffer.from('{"exp":0}').toString("base64url"),
+      "old-signature",
+    ].join(".");
+    jest.spyOn(fs, "existsSync").mockReturnValue(true);
+    jest.spyOn(fs, "readFileSync").mockReturnValue(expiredJwt);
+    mockExchangePublicKeyJwt.mockResolvedValue("fresh-jwt");
+    mockGet.mockResolvedValueOnce({ data: { data: [] } });
+
+    const client = new KnowhowSimpleClient("https://api.example.test");
+    await client.getModels();
+
+    expect(mockExchangePublicKeyJwt).toHaveBeenCalledWith(
+      "org-1",
+      "https://api.example.test",
+      "/tmp/identity"
+    );
+    expect(mockStoreJwt).toHaveBeenCalledWith("fresh-jwt");
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][1].headers.Authorization).toBe("Bearer fresh-jwt");
+  });
+});

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

@@ -0,0 +1,56 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+
+interface CapturedTransportOptions {
+  requestInit?: { headers?: Record<string, string> };
+}
+
+let capturedOptions: CapturedTransportOptions | undefined;
+
+jest.mock("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
+  StreamableHTTPClientTransport: jest.fn().mockImplementation(
+    (_url: URL, options: unknown) => {
+      capturedOptions = options as CapturedTransportOptions;
+      return { close: jest.fn() };
+    }
+  ),
+}));
+
+import { McpService } from "../../../src/services/Mcp";
+
+describe("McpService JWT file transport", () => {
+  let temporaryDirectory: string;
+  let tokenFile: string;
+
+  beforeEach(() => {
+    capturedOptions = undefined;
+    temporaryDirectory = fs.mkdtempSync(path.join(os.tmpdir(), "knowhow-mcp-"));
+    tokenFile = path.join(temporaryDirectory, ".jwt");
+  });
+
+  afterEach(() => {
+    fs.rmSync(temporaryDirectory, { recursive: true, force: true });
+  });
+
+  it("reads the refreshed JWT when the transport is created", () => {
+    fs.writeFileSync(tokenFile, "expired-jwt");
+    fs.writeFileSync(tokenFile, "fresh-jwt");
+
+    new McpService().createTransport({
+      name: "authenticated-remote",
+      url: "https://api.example.test/mcp",
+      authorization_token_file: tokenFile,
+    });
+
+    expect(capturedOptions).toEqual(
+      expect.objectContaining({
+        requestInit: {
+          headers: expect.objectContaining({
+            Authorization: "Bearer fresh-jwt",
+          }),
+        },
+      })
+    );
+  });
+});

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

@@ -0,0 +1,89 @@
+import { FsSyncedAgentWatcher } from "../../../src/services/watchers/FsSyncer";
+import { WebSyncedAgentWatcher } from "../../../src/services/watchers/RemoteSyncer";
+
+const retained = { role: "assistant", content: "before compaction" };
+const oldThread = [
+  { role: "system", content: "instructions" },
+  { role: "user", content: "task" },
+  retained,
+];
+const compactedThread = [
+  { role: "system", content: "instructions" },
+  { role: "user", content: "compressed summary" },
+  retained,
+  { role: "assistant", content: "after compaction" },
+];
+
+function seedCursor(watcher: any): void {
+  watcher.taskId = "task-1";
+  watcher.agentName = "Developer";
+  watcher.lastThreadIndex = 0;
+  watcher.lastThreadLength = oldThread.length;
+  watcher.lastMessageJson = JSON.stringify(retained);
+}
+
+describe("synced agent watcher thread rollover", () => {
+  it("continues rendering after filesystem agent compaction", async () => {
+    const watcher: any = new FsSyncedAgentWatcher();
+    seedCursor(watcher);
+    watcher.readMetadata = jest.fn().mockResolvedValue({
+      threads: [oldThread, compactedThread],
+      status: "running",
+    });
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onMetadataChanged();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadIndex).toBe(1);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+
+  it("continues rendering after web agent compaction", async () => {
+    const client = {
+      getTaskDetails: jest.fn().mockResolvedValue({
+        data: {
+          threads: [oldThread, compactedThread],
+          status: "running",
+        },
+      }),
+    };
+    const watcher: any = new WebSyncedAgentWatcher(client as any);
+    seedCursor(watcher);
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onPoll();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadIndex).toBe(1);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+
+  it("resets a cursor when a thread shrinks without changing index", async () => {
+    const watcher: any = new FsSyncedAgentWatcher();
+    seedCursor(watcher);
+    watcher.lastThreadLength = 10;
+    watcher.readMetadata = jest.fn().mockResolvedValue({
+      threads: [compactedThread],
+      status: "running",
+    });
+
+    const messages: string[] = [];
+    watcher.agentEvents.on(watcher.eventTypes.agentSay, (data: any) => {
+      messages.push(data.message);
+    });
+
+    await watcher.onMetadataChanged();
+
+    expect(messages).toEqual(["after compaction"]);
+    expect(watcher.lastThreadLength).toBe(compactedThread.length);
+  });
+});

package/tests/unit/tunnel.test.ts

@@ -0,0 +1,51 @@
+import { extractTunnelDomain } from "../../src/tunnel";
+
+describe("extractTunnelDomain", () => {
+  const originalTunnelWorkerDomain = process.env.TUNNEL_WORKER_DOMAIN;
+
+  beforeEach(() => {
+    delete process.env.TUNNEL_WORKER_DOMAIN;
+  });
+
+  afterAll(() => {
+    if (originalTunnelWorkerDomain === undefined) {
+      delete process.env.TUNNEL_WORKER_DOMAIN;
+    } else {
+      process.env.TUNNEL_WORKER_DOMAIN = originalTunnelWorkerDomain;
+    }
+  });
+
+  it("uses the local tunnel proxy for a localhost API URL", () => {
+    expect(extractTunnelDomain("http://localhost:4000")).toEqual({
+      domain: "worker.localhost:4000",
+      useHttps: false,
+    });
+  });
+
+  it("uses the local tunnel proxy for loopback API URLs", () => {
+    expect(extractTunnelDomain("http://127.0.0.1:4000")).toEqual({
+      domain: "worker.localhost:4000",
+      useHttps: false,
+    });
+  });
+
+  it("continues to select dev and production tunnel domains", () => {
+    expect(extractTunnelDomain("https://api.dev.knowhow.tyvm.ai")).toEqual({
+      domain: "worker.dev.tyvm-apps.com",
+      useHttps: true,
+    });
+    expect(extractTunnelDomain("https://api.knowhow.tyvm.ai")).toEqual({
+      domain: "worker.tyvm-apps.com",
+      useHttps: true,
+    });
+  });
+
+  it("allows an explicit tunnel domain to override localhost detection", () => {
+    process.env.TUNNEL_WORKER_DOMAIN = "worker.override.example";
+
+    expect(extractTunnelDomain("http://localhost:4000")).toEqual({
+      domain: "worker.override.example",
+      useHttps: false,
+    });
+  });
+});

package/ts_build/package.json

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

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

@@ -191,6 +191,7 @@ export declare abstract class BaseAgent implements IAgent {
         role: string;
         content: string;
     } | null;
+    extractContentFromMessages(messages: Message[]): string;
     getTaskBreakdown(messages: Message[]): Promise<string>;
     compressMessages(messages: Message[]): Promise<Message[]>;
 }

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

@@ -1017,6 +1017,17 @@ let BaseAgent = class BaseAgent {
         }
         return null;
     }
+    extractContentFromMessages(messages) {
+        const content = messages
+            .filter((m) => typeof m.content === "string" && m.content.trim())
+            .map((m) => m.content);
+        const finalAnswer = messages
+            .filter((m) => m.tool_calls?.length)
+            .flatMap((t) => t.tool_calls)
+            .filter((t) => t.function.name === "finalAnswer")
+            .map((t) => t.function.arguments);
+        return [...content, ...finalAnswer].join("\n\n");
+    }
     async getTaskBreakdown(messages) {
         if (this.taskBreakdown) {
             return this.taskBreakdown;
@@ -1039,22 +1050,12 @@ let BaseAgent = class BaseAgent {
             },
         ];
         const response = await this.createAgentCompletion({
-            model,
             messages: taskBreakdownMessages,
             tool_choice: "none",
-            long_ttl_cache: this.runTime() > 300_000,
-            ...(this.reasoningEffort !== undefined && {
-                reasoning_effort: this.reasoningEffort,
-            }),
-            ...(this.summarizeReasoning !== undefined && {
-                reasoning_summary: this.summarizeReasoning,
-            }),
         });
-        const breakdownContent = response.choices
-            .map((c) => c.message.content)
-            .filter((s) => typeof s === "string" && s.trim().length > 0)
-            .join("\n\n");
+        const breakdownContent = this.extractContentFromMessages(response.choices?.map((c) => c.message));
         if (!breakdownContent) {
+            console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction task-breakdown request returned no text content");
         }
         this.taskBreakdown = breakdownContent;
@@ -1063,8 +1064,7 @@ let BaseAgent = class BaseAgent {
     }
     async compressMessages(messages) {
         let resumeIndex = messages.length - 1;
-        while (resumeIndex >= 0 &&
-            messages[resumeIndex].role !== "assistant") {
+        while (resumeIndex >= 0 && messages[resumeIndex].role !== "assistant") {
             resumeIndex--;
         }
         const compressionEnd = resumeIndex === -1 ? messages.length : resumeIndex;
@@ -1080,7 +1080,9 @@ let BaseAgent = class BaseAgent {
     3. Next Steps - what we're about to do next to continue the user's original request.
     4. Tasks remaining - what tasks are left from the initial task breakdown.
 
-    ${this.taskBreakdown ? `Our initial task breakdown: ${this.taskBreakdown}` : ""}
+    ${this.taskBreakdown
+            ? `Our initial task breakdown: ${this.taskBreakdown}`
+            : ""}
 
     This summary will replace the older history. The latest agent interaction will remain verbatim:
 
@@ -1096,21 +1098,24 @@ let BaseAgent = class BaseAgent {
             messages: compressMessagesPayload,
             tool_choice: "none",
         });
-        const summaries = response.choices
-            .map((c) => c.message.content)
-            .filter((s) => typeof s === "string" && s.trim().length > 0);
-        if (summaries.length === 0) {
+        const summary = this.extractContentFromMessages(response.choices?.map((c) => c.message));
+        if (summary.length === 0) {
+            console.log(JSON.stringify(response.choices, null, 2));
             throw new Error("Compaction summary request returned no text content");
         }
-        this.summaries.push(...summaries);
+        this.summaries.push(summary);
         const startMessages = [
             {
                 role: "user",
                 content: `
-        ${this.taskBreakdown ? `Initial task breakdown:\n        ${this.taskBreakdown}` : "(No task breakdown available — summarize what you know from context above)"}
+        ${this.taskBreakdown
+                    ? `Initial task breakdown:\n        ${this.taskBreakdown}`
+                    : "(No task breakdown available — summarize what you know from context above)"}
 
         We have just compressed the conversation to save memory:
-        ${summaries.length > 0 ? JSON.stringify(summaries) : "(summary unavailable — please continue from the task breakdown above)"}
+        ${summary.length > 0
+                    ? JSON.stringify(summary)
+                    : "(summary unavailable — please continue from the task breakdown above)"}
 
         Please continue the task from where we left off
         `,