@tyvm/knowhow 0.0.105 → 0.0.107

package/src/worker.ts

@@ -578,3 +578,177 @@ export async function worker(options?: {
     await wait(5000);
   }
 }
+
+/**
+ * Run tunnel-only mode: connects to the Knowhow tunnel WebSocket without
+ * registering any MCP tools. Useful for users who only want the web tunnel
+ * feature to expose local ports to the cloud.
+ */
+export async function tunnel(options?: {
+  share?: boolean;
+  unshare?: boolean;
+}) {
+  const config = await getConfig();
+
+  const isInsideDocker = process.env.KNOWHOW_DOCKER === "true";
+
+  // Determine localHost based on environment
+  let tunnelLocalHost = config.worker?.tunnel?.localHost;
+  if (!tunnelLocalHost) {
+    if (isInsideDocker) {
+      tunnelLocalHost = "host.docker.internal";
+      console.log(
+        "🐳 Docker detected: tunnel will use host.docker.internal to reach host services"
+      );
+    } else {
+      tunnelLocalHost = "127.0.0.1";
+    }
+  }
+
+  // Check for port mapping configuration
+  const portMapping = config.worker?.tunnel?.portMapping || {};
+  if (Object.keys(portMapping).length > 0) {
+    console.log("🔀 Port mapping configured:");
+    for (const [containerPort, hostPort] of Object.entries(portMapping)) {
+      console.log(`   Container port ${containerPort} → Host port ${hostPort}`);
+    }
+  }
+
+  const tunnelPorts = config.worker?.tunnel?.allowedPorts || [];
+  if (tunnelPorts.length === 0) {
+    console.warn(
+      "⚠️  No allowedPorts configured. Add worker.tunnel.allowedPorts to knowhow.json"
+    );
+  } else {
+    console.log(`🌐 Tunnel mode for ports: ${tunnelPorts.join(", ")}`);
+  }
+
+  // Extract tunnel domain from API_URL
+  function extractTunnelDomain(apiUrl: string): {
+    domain: string;
+    useHttps: boolean;
+  } {
+    try {
+      const url = new URL(apiUrl);
+      const useHttps = url.protocol === "https:";
+      if (url.hostname === "localhost" || url.hostname === "127.0.0.1") {
+        return {
+          domain: `worker.${url.hostname}:${url.port || "80"}`,
+          useHttps,
+        };
+      }
+      return { domain: `worker.${url.hostname}`, useHttps };
+    } catch (err) {
+      console.error("Failed to parse API_URL for tunnel domain:", err);
+      return { domain: "worker.localhost:4000", useHttps: false };
+    }
+  }
+
+  let connected = false;
+  let tunnelHandler: TunnelHandler | null = null;
+  let lastJwt: string | null = null;
+  let unauthorizedJwt: string | null = null;
+
+  async function connectTunnel() {
+    const jwt = await loadJwt();
+    lastJwt = jwt;
+    console.log(`Connecting tunnel to ${API_URL}`);
+
+    const dir = process.cwd();
+    const homedir = os.homedir();
+    const hostname = process.env.WORKER_HOSTNAME || os.hostname();
+    const root =
+      process.env.WORKER_ROOT ||
+      (dir === homedir ? "~" : dir.replace(homedir, "~"));
+
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${jwt}`,
+      "User-Agent": `knowhow-tunnel/1.0.0/${hostname}`,
+      Root: root,
+    };
+
+    if (options?.share) {
+      headers.Shared = "true";
+      console.log("🔓 Tunnel shared with organization");
+    } else if (options?.unshare) {
+      headers.Shared = "false";
+      console.log("🔒 Tunnel is now private (unshared)");
+    } else {
+      console.log("🔒 Tunnel is private (only you can use it)");
+    }
+
+    const { domain: tunnelDomain, useHttps: tunnelUseHttps } =
+      extractTunnelDomain(API_URL);
+
+    const tunnelConnection = new WebSocket(`${API_URL}/ws/tunnel`, { headers });
+
+    tunnelConnection.on("open", () => {
+      console.log("🌐 Tunnel WebSocket connected");
+      connected = true;
+
+      const allowedPorts = config.worker?.tunnel?.allowedPorts || [];
+      const urlRewriter = (port: number, metadata?: any) => {
+        const workerId = metadata?.workerId;
+        const secret = metadata?.secret;
+        const subdomain = secret ? `${secret}-p${port}` : `${workerId}-p${port}`;
+        return `${subdomain}.${tunnelDomain}`;
+      };
+
+      const tunnelConfig = {
+        allowedPorts,
+        maxConcurrentStreams: config.worker?.tunnel?.maxConcurrentStreams || 50,
+        tunnelUseHttps,
+        localHost: tunnelLocalHost,
+        urlRewriter,
+        enableUrlRewriting: config.worker?.tunnel?.enableUrlRewriting !== false,
+        portMapping,
+        logLevel: "debug" as const,
+      };
+
+      tunnelHandler = createTunnelHandler(tunnelConnection, tunnelConfig);
+      console.log("🌐 Tunnel handler initialized");
+      console.log(tunnelConfig);
+    });
+
+    tunnelConnection.on("close", (code, reason) => {
+      console.log(`Tunnel WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`);
+      if (code === 1008) {
+        unauthorizedJwt = lastJwt;
+        console.error("❌ Tunnel received Unauthorized (1008). The JWT may be expired.");
+        console.error("   Run 'knowhow login' to refresh your token, then restart.");
+        console.error("   Pausing reconnection until JWT changes...");
+      } else {
+        console.log("Tunnel connection will reconnect on next cycle...");
+      }
+      if (tunnelHandler) {
+        tunnelHandler.cleanup();
+        tunnelHandler = null;
+      }
+      connected = false;
+    });
+
+    tunnelConnection.on("error", (error) => {
+      console.error("Tunnel WebSocket error:", error);
+      connected = false;
+    });
+
+    return tunnelConnection;
+  }
+
+  while (true) {
+    if (!connected) {
+      if (unauthorizedJwt !== null) {
+        const currentJwt = await loadJwt().catch(() => null);
+        if (currentJwt === unauthorizedJwt) {
+          await wait(5000);
+          continue;
+        }
+        console.log("🔄 JWT has changed, attempting to reconnect tunnel...");
+        unauthorizedJwt = null;
+      }
+      console.log("Attempting to connect tunnel...");
+      await connectTunnel();
+    }
+    await wait(5000);
+  }
+}

package/tests/clients/AIClient.test.ts

@@ -42,7 +42,7 @@ class FakeClient implements GenericClient {
         },
       ],
       model: options.model,
-      usage: { total_tokens: 100 },
+      usage: { prompt_tokens: 50, completion_tokens: 50, total_tokens: 100 },
     };
   }
 

package/tests/clients/anthropic.test.ts

@@ -0,0 +1,202 @@
+import { GenericAnthropicClient } from "../../src/clients/anthropic";
+
+// We only need to test transformMessages, which doesn't require an API key
+function createClient() {
+  return new GenericAnthropicClient("fake-key");
+}
+
+describe("GenericAnthropicClient.transformMessages", () => {
+  let client: GenericAnthropicClient;
+
+  beforeEach(() => {
+    client = createClient();
+  });
+
+  it("should handle a simple user message", () => {
+    const messages = [
+      { role: "user" as const, content: "Hello" },
+    ];
+    const result = client.transformMessages(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe("user");
+    expect(result[0].content).toBe("Hello");
+  });
+
+  it("should filter out system messages", () => {
+    const messages = [
+      { role: "system" as const, content: "You are helpful" },
+      { role: "user" as const, content: "Hello" },
+    ];
+    const result = client.transformMessages(messages);
+    expect(result).toHaveLength(1);
+    expect(result[0].role).toBe("user");
+  });
+
+  it("should inject tool_use assistant block when processing tool result", () => {
+    // Simulates: assistant responds with tool_call (content: ""), then tool result comes back
+    const messages = [
+      { role: "user" as const, content: "Use a tool" },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_abc123",
+            type: "function" as const,
+            function: {
+              name: "listAvailableTools",
+              arguments: "{}",
+            },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_abc123",
+        name: "listAvailableTools",
+        content: '{"enabled": ["finalAnswer"], "disabled": []}',
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Should have: user msg, assistant tool_use block, user tool_result block
+    expect(result.length).toBeGreaterThanOrEqual(2);
+
+    // Find the assistant message with tool_use
+    const assistantMsg = result.find(
+      (m) =>
+        m.role === "assistant" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_use")
+    );
+    expect(assistantMsg).toBeDefined();
+    const toolUseBlock = (assistantMsg!.content as any[]).find(
+      (c) => c.type === "tool_use"
+    );
+    expect(toolUseBlock.id).toBe("toolu_abc123");
+    expect(toolUseBlock.name).toBe("listAvailableTools");
+
+    // Find the user message with tool_result
+    const userToolResult = result.find(
+      (m) =>
+        m.role === "user" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_result")
+    );
+    expect(userToolResult).toBeDefined();
+    const toolResultBlock = (userToolResult!.content as any[]).find(
+      (c) => c.type === "tool_result"
+    );
+    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
+  });
+
+  it("should not have undefined tool_use_id when assistant message has empty content with tool_calls", () => {
+    // This is the failing scenario: assistant has content: "" (falsy) but has tool_calls
+    const messages = [
+      { role: "user" as const, content: "Use a tool" },
+      {
+        role: "assistant" as const,
+        content: "",  // empty string - would be filtered by `msg.content` check
+        tool_calls: [
+          {
+            id: "toolu_abc123",
+            type: "function" as const,
+            function: {
+              name: "listAvailableTools",
+              arguments: "{}",
+            },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_abc123",
+        name: "listAvailableTools",
+        content: '{"enabled": ["finalAnswer"]}',
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Find the user message with tool_result - tool_use_id must NOT be undefined
+    const userToolResult = result.find(
+      (m) =>
+        m.role === "user" &&
+        Array.isArray(m.content) &&
+        (m.content as any[]).some((c) => c.type === "tool_result")
+    );
+    expect(userToolResult).toBeDefined();
+    const toolResultBlock = (userToolResult!.content as any[]).find(
+      (c) => c.type === "tool_result"
+    );
+    // This should be "toolu_abc123", NOT undefined
+    expect(toolResultBlock.tool_use_id).toBe("toolu_abc123");
+    expect(toolResultBlock.tool_use_id).not.toBeUndefined();
+  });
+
+  it("should handle multiple sequential tool calls", () => {
+    const messages = [
+      { role: "user" as const, content: "Do two things" },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_111",
+            type: "function" as const,
+            function: { name: "toolOne", arguments: "{}" },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_111",
+        name: "toolOne",
+        content: "result one",
+      },
+      {
+        role: "assistant" as const,
+        content: "",
+        tool_calls: [
+          {
+            id: "toolu_222",
+            type: "function" as const,
+            function: { name: "toolTwo", arguments: "{}" },
+          },
+        ],
+      },
+      {
+        role: "tool" as const,
+        tool_call_id: "toolu_222",
+        name: "toolTwo",
+        content: "result two",
+      },
+    ];
+
+    const result = client.transformMessages(messages);
+
+    // Both tool results should have correct tool_use_ids
+    const toolResults = result
+      .filter((m) => m.role === "user" && Array.isArray(m.content))
+      .flatMap((m) => (m.content as any[]).filter((c) => c.type === "tool_result"));
+
+    expect(toolResults).toHaveLength(2);
+    const ids = toolResults.map((r) => r.tool_use_id);
+    expect(ids).toContain("toolu_111");
+    expect(ids).toContain("toolu_222");
+    expect(ids).not.toContain(undefined);
+  });
+
+  it("should not crash when response is undefined (Cannot use in operator bug)", () => {
+    // Test that the base agent undefined response check doesn't throw
+    // This tests the guard we added to base.ts
+    const undefinedLike = undefined as any;
+    // Should not throw "Cannot use 'in' operator to search for 'response' in undefined"
+    expect(() => {
+      if (undefinedLike != null && "response" in undefinedLike) {
+        // This should not be reached
+      }
+    }).not.toThrow();
+  });
+});

package/tests/clients/pricing.test.ts

@@ -5,6 +5,9 @@
  * Models that are image-only, video-only, TTS, transcription, realtime, or live streaming
  * are exempt from text pricing requirements — they should have their own pricing entries
  * in the appropriate pricing tables (image, video, audio, etc.).
+ * 
+ * Also verifies that every model in Models.* and EmbeddingModels.* has a catalog entry,
+ * ensuring the catalog stays in sync with the model definitions.
  */
 
 import {
@@ -27,6 +30,7 @@ import {
   GeminiTextPricing,
   AnthropicTextPricing,
   XaiTextPricing,
+  ALL_MODEL_CATALOG,
   XaiImagePricing,
   XaiVideoPricing,
 } from "../../src/clients/pricing";
@@ -140,5 +144,38 @@ describe("Model Pricing Coverage", () => {
         expect(entry).toBeDefined();
       });
     }
+
+describe("Model Catalog Coverage", () => {
+  /**
+   * Every model defined in Models.* and EmbeddingModels.* must have an entry
+   * in ALL_MODEL_CATALOG. This ensures the catalog stays in sync and is the
+   * single source of truth for model metadata and pricing.
+   */
+  const catalogIds = new Set(ALL_MODEL_CATALOG.map((m) => m.id));
+
+  describe("All Models.* entries are in the catalog", () => {
+    for (const [provider, providerModels] of Object.entries(Models)) {
+      for (const [modelKey, modelId] of Object.entries(
+        providerModels as Record<string, string>
+      )) {
+        it(`Models.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+          expect(catalogIds.has(modelId)).toBe(true);
+        });
+      }
+    }
+  });
+
+  describe("All EmbeddingModels.* entries are in the catalog", () => {
+    for (const [provider, providerModels] of Object.entries(EmbeddingModels)) {
+      for (const [modelKey, modelId] of Object.entries(
+        providerModels as Record<string, string>
+      )) {
+        it(`EmbeddingModels.${provider}.${modelKey} (${modelId}) is in ALL_MODEL_CATALOG`, () => {
+          expect(catalogIds.has(modelId)).toBe(true);
+        });
+      }
+    }
+  });
+});
   });
 });