@tyvm/knowhow 0.0.64 → 0.0.66

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tyvm/knowhow",
-  "version": "0.0.64",
+  "version": "0.0.66",
   "description": "ai cli with plugins and agents",
   "main": "ts_build/src/index.js",
   "bin": {
@@ -40,6 +40,7 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",
     "@aws-sdk/client-s3": "^3.588.0",
+    "@tyvm/knowhow-tunnel": "^0.0.1",
     "@google/genai": "^0.14.1",
     "@inquirer/editor": "^4.2.18",
     "@linear/sdk": "^12.0.0",

package/src/chat/modules/AgentModule.ts

@@ -634,11 +634,19 @@ Please continue from where you left off and complete the original request.
 
       const taskCompleted = new Promise<string>((resolve) => {
         agent.agentEvents.once(agent.eventTypes.done, async (doneMsg) => {
-          console.log("Agent has completed the task.");
+          console.log("🎯 [AgentModule] Task Completed");
           done = true;
           output = doneMsg || "No response from the AI";
           // Update task info
           taskInfo = this.taskRegistry.get(taskId);
+
+          // Wait for AgentSync to finish before resolving
+          if (knowhowTaskId) {
+            console.log("🎯 [AgentModule] Waiting for sync finalization...");
+            await this.agentSync.waitForFinalization();
+            console.log("🎯 [AgentModule] Sync finalization complete");
+          }
+
           if (taskInfo) {
             taskInfo.status = "completed";
             // Update final cost from agent
@@ -647,7 +655,9 @@ Please continue from where you left off and complete the original request.
             this.updateSession(taskId, agent.getThreads());
             taskInfo.endTime = Date.now();
           }
+
           console.log(Marked.parse(output));
+          console.log("🎯 [AgentModule] Task Complete");
           resolve(doneMsg);
         });
       });

package/src/cli.ts

@@ -54,10 +54,11 @@ async function setupServices() {
   // Add Mcp service to tool context directly so MCP management tools can access it
   Tools.addContext("Mcp", Mcp);
 
-  await Promise.all([
-    Mcp.connectToConfigured(Tools),
-    Clients.registerConfiguredModels(),
-  ]);
+  console.log("🔌 Connecting to MCP...");
+  await Mcp.connectToConfigured(Tools);
+  console.log("Connecting to clients...");
+  await Clients.registerConfiguredModels();
+  console.log("✓ Services are set up and ready to go!");
 }
 
 // Utility function to read from stdin

package/src/clients/anthropic.ts

@@ -125,24 +125,14 @@ export class GenericAnthropicClient implements GenericClient {
   handleMessageCaching(groupedMessages: MessageParam[]) {
     this.handleClearingCache(groupedMessages);
 
-    const hasTwoUserMesages =
-      groupedMessages.filter((m) => m.role === "user").length >= 2;
-
-    const firstUserMessage = groupedMessages.find((m) => m.role === "user");
-    if (firstUserMessage) {
-      this.cacheLastContent(firstUserMessage);
-    }
-
-    if (hasTwoUserMesages) {
-      // find the last two messages and mark them as ephemeral
-      const lastTwoUserMessages = groupedMessages
-        .filter((m) => m.role === "user")
-        .slice(-2);
-
-      for (const m of lastTwoUserMessages) {
-        if (Array.isArray(m.content)) {
-          this.cacheLastContent(m);
-        }
+    // find the last two messages and mark them as ephemeral
+    const lastTwoUserMessages = groupedMessages
+      .filter((m) => m.role === "user")
+      .slice(-2);
+
+    for (const m of lastTwoUserMessages) {
+      if (Array.isArray(m.content)) {
+        this.cacheLastContent(m);
       }
     }
   }
@@ -185,33 +175,39 @@ export class GenericAnthropicClient implements GenericClient {
           }
 
           // Convert tool message content to appropriate format
-          let toolResultContent: string | (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[];
-          
+          let toolResultContent:
+            | string
+            | (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[];
+
           if (typeof msg.content === "string") {
             toolResultContent = msg.content;
           } else if (Array.isArray(msg.content)) {
             // Transform image_url format to Anthropic's image format
-            toolResultContent = msg.content.map((item): Anthropic.TextBlockParam | Anthropic.ImageBlockParam => {
-              if (item.type === "image_url") {
-                const url = item.image_url.url;
-                const isDataUrl = url.startsWith("data:");
-                const base64Data = isDataUrl ? url.split(",")[1] : url;
-                const mediaType = isDataUrl ? url.match(/data:([^;]+);/)?.[1] || "image/jpeg" : "image/jpeg";
-                
-                return {
-                  type: "image" as const,
-                  source: {
-                    type: "base64" as const,
-                    media_type: mediaType as any,
-                    data: base64Data,
-                  },
-                };
-              } else if (item.type === "text") {
-                return { type: "text" as const, text: item.text };
+            toolResultContent = msg.content.map(
+              (item): Anthropic.TextBlockParam | Anthropic.ImageBlockParam => {
+                if (item.type === "image_url") {
+                  const url = item.image_url.url;
+                  const isDataUrl = url.startsWith("data:");
+                  const base64Data = isDataUrl ? url.split(",")[1] : url;
+                  const mediaType = isDataUrl
+                    ? url.match(/data:([^;]+);/)?.[1] || "image/jpeg"
+                    : "image/jpeg";
+
+                  return {
+                    type: "image" as const,
+                    source: {
+                      type: "base64" as const,
+                      media_type: mediaType as any,
+                      data: base64Data,
+                    },
+                  };
+                } else if (item.type === "text") {
+                  return { type: "text" as const, text: item.text };
+                }
+                // Fallback for unknown types
+                return { type: "text" as const, text: String(item) };
               }
-              // Fallback for unknown types
-              return { type: "text" as const, text: String(item) };
-            }) as (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[];
+            ) as (Anthropic.TextBlockParam | Anthropic.ImageBlockParam)[];
           } else {
             toolResultContent = String(msg.content);
           }
@@ -293,7 +289,7 @@ export class GenericAnthropicClient implements GenericClient {
           ? [
               {
                 text: systemMessage,
-                // cache_control: { type: "ephemeral" },
+                cache_control: { type: "ephemeral" },
                 type: "text",
               },
             ]
@@ -359,9 +355,19 @@ export class GenericAnthropicClient implements GenericClient {
     return {
       [Models.anthropic.Opus4_6]: {
         input: 5.0,
+        input_gt_200k: 10.0,
         cache_write: 6.25,
         cache_hit: 0.5,
         output: 25.0,
+        output_gt_200k: 37.5,
+      },
+      [Models.anthropic.Sonnet4_6]: {
+        input: 3.0,
+        input_gt_200k: 6.0,
+        cache_write: 3.75,
+        cache_hit: 0.3,
+        output: 15.0,
+        output_gt_200k: 22.5,
       },
       [Models.anthropic.Opus4_5]: {
         input: 5.0,
@@ -383,15 +389,19 @@ export class GenericAnthropicClient implements GenericClient {
       },
       [Models.anthropic.Sonnet4]: {
         input: 3.0,
+        input_gt_200k: 6.0,
         cache_write: 3.75,
         cache_hit: 0.3,
         output: 15.0,
+        output_gt_200k: 22.5,
       },
       [Models.anthropic.Sonnet4_5]: {
         input: 3.0,
+        input_gt_200k: 6.0,
         cache_write: 3.75,
         cache_hit: 0.3,
         output: 15.0,
+        output_gt_200k: 22.5,
       },
       [Models.anthropic.Haiku4_5]: {
         input: 1,
@@ -413,8 +423,8 @@ export class GenericAnthropicClient implements GenericClient {
       },
       [Models.anthropic.Haiku3_5]: {
         input: 0.8,
-        cache_write: 1.25,
-        cache_hit: 0.1,
+        cache_write: 1.0,
+        cache_hit: 0.08,
         output: 4.0,
       },
       [Models.anthropic.Opus3]: {
@@ -425,34 +435,45 @@ export class GenericAnthropicClient implements GenericClient {
       },
       [Models.anthropic.Haiku3]: {
         input: 0.25,
-        cache_write: 0.3,
-        cache_hit: 0.03,
+        cache_write: 0.3125,
+        cache_hit: 0.025,
         output: 1.25,
       },
     };
   }
 
   calculateCost(model: string, usage: Usage): number | undefined {
-    const pricing = this.pricesPerMillion()[model];
-
-    if (!pricing) {
-      return undefined;
-    }
-
-    const cachedInputTokens = usage.cache_creation_input_tokens;
-    const cachedInputCost = (cachedInputTokens * pricing.cache_write) / 1e6;
-
-    const cachedReadTokens = usage.cache_read_input_tokens;
-    const cachedReadCost = (cachedReadTokens * pricing.cache_hit) / 1e6;
-
-    const inputTokens = usage.input_tokens;
-    const inputCost = ((inputTokens - cachedInputCost) * pricing.input) / 1e6;
-
-    const outputTokens = usage.output_tokens;
-    const outputCost = (outputTokens * pricing.output) / 1e6;
-
-    const total = cachedInputCost + inputCost + outputCost;
-    return total;
+    const p = this.pricesPerMillion()[model];
+    if (!p) return undefined;
+
+    const inputTokens = usage.input_tokens ?? 0;
+    const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0;
+    const cacheReadTokens = usage.cache_read_input_tokens ?? 0;
+    const outputTokens = usage.output_tokens ?? 0;
+
+    const totalInputTokens = inputTokens + cacheWriteTokens + cacheReadTokens;
+
+    const useLongContextTier = totalInputTokens > 200_000 && !!p.input_gt_200k;
+    const inputRate = useLongContextTier
+      ? (p.input_gt_200k as number)
+      : p.input;
+    const outputRate =
+      useLongContextTier && p.output_gt_200k ? p.output_gt_200k : p.output;
+
+    // Prefer modeling cache pricing as multipliers, but if you keep absolute numbers,
+    // you MUST scale them when usingLongContextTier.
+    //
+    // Anthropic docs describe cache read/write as multipliers of the base input rate. :contentReference[oaicite:7]{index=7}
+    // If your `cache_write` + `cache_hit` are absolute $/MTok at base tier, scale them:
+    const cacheWriteRate = (p.cache_write / p.input) * inputRate; // preserves your multiplier
+    const cacheReadRate = (p.cache_hit / p.input) * inputRate; // preserves your multiplier
+
+    const nonCachedInputCost = (inputTokens * inputRate) / 1e6;
+    const cacheWriteCost = (cacheWriteTokens * cacheWriteRate) / 1e6;
+    const cacheReadCost = (cacheReadTokens * cacheReadRate) / 1e6;
+    const outputCost = (outputTokens * outputRate) / 1e6;
+
+    return nonCachedInputCost + cacheWriteCost + cacheReadCost + outputCost;
   }
 
   async getModels() {

package/src/config.ts

@@ -87,6 +87,13 @@ const defaultConfig = {
     logLevel: "info",
     completionTimeout: 5000,
   },
+
+  worker: {
+    tunnel: {
+      enabled: false,
+      allowedPorts: [],
+    },
+  },
 } as Config;
 
 const defaultLanguage = {

package/src/services/AgentSynchronization.ts

@@ -32,6 +32,7 @@ export class AgentSynchronization {
   private baseUrl: string;
   private knowhowTaskId: string | undefined;
   private eventHandlersSetup: boolean = false;
+  private finalizationPromise: Promise<void> | null = null;
 
   constructor(baseUrl: string = KNOWHOW_API_URL) {
     this.baseUrl = baseUrl;
@@ -248,28 +249,44 @@ export class AgentSynchronization {
     // Listen to completion event to finalize task
     agent.agentEvents.on(agent.eventTypes.done, async (result: string) => {
       if (!this.knowhowTaskId || !this.baseUrl) {
+        console.warn(`⚠️ [AgentSync] Cannot finalize: knowhowTaskId=${this.knowhowTaskId}, baseUrl=${this.baseUrl}`);
         return;
       }
 
-      try {
-        await wait(200);
-        console.log(
-          `Updating Knowhow chat task on completion..., ${this.knowhowTaskId}`
-        );
-        await this.updateChatTask(this.knowhowTaskId, agent, false, result);
-        console.log(`✅ Completed Knowhow chat task: ${this.knowhowTaskId}`);
-      } catch (error) {
-        console.error(`❌ Error finalizing task:`, error);
-      }
+      console.log(`🎯 [AgentSync] Done event received for task: ${this.knowhowTaskId}`);
+      
+      // Create a promise that tracks finalization
+      this.finalizationPromise = (async () => {
+        try {
+          console.log(
+            `Updating Knowhow chat task on completion..., ${this.knowhowTaskId}`
+          );
+          await this.updateChatTask(this.knowhowTaskId!, agent, false, result);
+          console.log(`✅ Completed Knowhow chat task: ${this.knowhowTaskId}`);
+        } catch (error) {
+          console.error(`❌ Error finalizing task:`, error);
+          throw error; // Re-throw so CLI can handle it
+        }
+      })();
     });
   }
 
+  /**
+   * Wait for finalization to complete (for CLI usage)
+   */
+  async waitForFinalization(): Promise<void> {
+    if (this.finalizationPromise) {
+      await this.finalizationPromise;
+    }
+  }
+
   /**
    * Reset synchronization state (useful for reusing the service)
    */
   reset(): void {
     this.knowhowTaskId = undefined;
     this.eventHandlersSetup = false;
+    this.finalizationPromise = null;
   }
 
   /**

package/src/types.ts

@@ -66,6 +66,16 @@ export type Config = {
     sandbox?: boolean;
     volumes?: string[];
     envFile?: string;
+    tunnel?: {
+      enabled?: boolean;
+      allowedPorts?: number[];
+      maxConcurrentStreams?: number;
+      portMapping?: {
+        [containerPort: number]: number; // containerPort -> hostPort
+      };
+      localHost?: string; // Default: "127.0.0.1", can be "host.docker.internal" for Docker
+      enableUrlRewriting?: boolean; // Enable URL rewriting for localhost URLs (default: true)
+    };
   };
 };
 
@@ -143,6 +153,7 @@ export type ChatInteraction = {
 export const Models = {
   anthropic: {
     Opus4_6: "claude-opus-4-6",
+    Sonnet4_6: "claude-sonnet-4-6",
     Opus4_5: "claude-opus-4-5-20251101",
     Opus4: "claude-opus-4-20250514",
     Opus4_1: "claude-opus-4-1-20250805",

package/src/worker.ts

@@ -1,10 +1,12 @@
 import os from "os";
 import { WebSocket } from "ws";
+import { createTunnelHandler, TunnelHandler } from "@tyvm/knowhow-tunnel";
 import { includedTools } from "./agents/tools/list";
 import { loadJwt } from "./login";
 import { services } from "./services";
 import { McpServerService } from "./services/Mcp";
 import * as allTools from "./agents/tools";
+import workerTools from "./workers/tools";
 import { wait } from "./utils";
 import { getConfig, updateConfig } from "./config";
 import { KNOWHOW_API_URL } from "./services/KnowhowClient";
@@ -88,9 +90,11 @@ export async function worker(options?: {
 
   // Check if we're already running inside a Docker container
   const isInsideDocker = process.env.KNOWHOW_DOCKER === "true";
-  
+
   if (isInsideDocker) {
-    console.log("🐳 Already running inside Docker container, skipping sandbox mode");
+    console.log(
+      "🐳 Already running inside Docker container, skipping sandbox mode"
+    );
     // Force sandbox mode off when inside Docker to prevent nested containers
     if (options) {
       options.sandbox = false;
@@ -145,6 +149,11 @@ export async function worker(options?: {
   }
 
   const { Tools } = services();
+  // Combine agent tools and worker-specific tools
+  const combinedTools = { ...allTools, ...workerTools.tools };
+  Tools.defineTools(includedTools, combinedTools);
+  Tools.defineTools(workerTools.definitions, workerTools.tools);
+
   const mcpServer = new McpServerService(Tools);
   const clientName = "knowhow-worker";
   const clientVersion = "1.1.1";
@@ -178,6 +187,74 @@ export async function worker(options?: {
   mcpServer.createServer(clientName, clientVersion).withTools(toolsToUse);
 
   let connected = false;
+  let tunnelHandler: TunnelHandler | null = null;
+  let tunnelWs: WebSocket | null = null;
+
+  // Check if tunnel is enabled
+  const tunnelEnabled = config.worker?.tunnel?.enabled ?? false;
+
+  // Determine localHost based on environment
+  let tunnelLocalHost = config.worker?.tunnel?.localHost;
+  if (!tunnelLocalHost) {
+    // Auto-detect based on Docker environment
+    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}`);
+    }
+  }
+
+  if (tunnelEnabled) {
+    const tunnelPorts = config.worker?.tunnel?.allowedPorts || [];
+    if (tunnelPorts.length === 0) {
+      console.warn(
+        "⚠️  Tunnel enabled but no allowedPorts configured. Add tunnel.allowedPorts to knowhow.json"
+      );
+    } else {
+      console.log(`🌐 Tunnel enabled for ports: ${tunnelPorts.join(", ")}`);
+    }
+  } else {
+    console.log(
+      "🚫 Tunnel disabled (enable in knowhow.json: worker.tunnel.enabled = true)"
+    );
+  }
+
+  // Extract tunnel domain from API_URL
+  // e.g., "https://api.knowhow.tyvm.ai" -> "knowhow.tyvm.ai"
+  // e.g., "http://localhost:4000" -> "localhost:4000"
+  function extractTunnelDomain(apiUrl: string): {
+    domain: string;
+    useHttps: boolean;
+  } {
+    try {
+      const url = new URL(apiUrl);
+      const useHttps = url.protocol === "https:";
+
+      // For localhost, include port; for production, just use hostname
+      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 }; // fallback
+    }
+  }
 
   async function connectWebSocket() {
     const jwt = await loadJwt();
@@ -185,10 +262,12 @@ export async function worker(options?: {
 
     const dir = process.cwd();
     const homedir = os.homedir();
-    
+
     // Use environment variables if available (set by Docker), otherwise compute defaults
     const hostname = process.env.WORKER_HOSTNAME || os.hostname();
-    const root = process.env.WORKER_ROOT || (dir === homedir ? "~" : dir.replace(homedir, "~"));
+    const root =
+      process.env.WORKER_ROOT ||
+      (dir === homedir ? "~" : dir.replace(homedir, "~"));
 
     const headers: Record<string, string> = {
       Authorization: `Bearer ${jwt}`,
@@ -207,12 +286,61 @@ export async function worker(options?: {
       console.log("🔒 Worker is private (only you can use it)");
     }
 
+    const { domain: tunnelDomain, useHttps: tunnelUseHttps } =
+      extractTunnelDomain(API_URL);
+
     const ws = new WebSocket(`${API_URL}/ws/worker`, {
       headers,
     });
 
+    // Create separate WebSocket connection for tunnel if enabled
+    let tunnelConnection: WebSocket | null = null;
+    if (tunnelEnabled) {
+      tunnelConnection = new WebSocket(`${API_URL}/ws/tunnel`, {
+        headers,
+      });
+
+      tunnelConnection.on("open", () => {
+        console.log("Tunnel WebSocket connected");
+
+        // Initialize tunnel handler with the tunnel-specific WebSocket
+        tunnelHandler = createTunnelHandler(tunnelConnection!, {
+          allowedPorts: config.worker?.tunnel?.allowedPorts || [],
+          maxConcurrentStreams:
+            config.worker?.tunnel?.maxConcurrentStreams || 50,
+          localHost: tunnelLocalHost,
+          tunnelDomain,
+          tunnelUseHttps,
+          enableUrlRewriting:
+            config.worker?.tunnel?.enableUrlRewriting !== false,
+          portMapping,
+          logLevel: "info",
+        });
+        console.log("🌐 Tunnel handler initialized");
+      });
+
+      tunnelConnection.on("close", (code, reason) => {
+        console.log(
+          `Tunnel WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`
+        );
+
+        // Cleanup tunnel handler
+        if (tunnelHandler) {
+          tunnelHandler.cleanup();
+          tunnelHandler = null;
+        }
+        tunnelWs = null;
+      });
+
+      tunnelConnection.on("error", (error) => {
+        console.error("Tunnel WebSocket error:", error);
+      });
+
+      tunnelWs = tunnelConnection;
+    }
+
     ws.on("open", () => {
-      console.log("Connected to the server");
+      console.log("Worker WebSocket connected");
       connected = true;
     });
 
@@ -221,6 +349,12 @@ export async function worker(options?: {
         `WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`
       );
       console.log("Attempting to reconnect...");
+
+      // Cleanup tunnel handler
+      if (tunnelHandler) {
+        tunnelHandler = null;
+      }
+
       connected = false;
     });
 
@@ -230,12 +364,15 @@ export async function worker(options?: {
 
     mcpServer.runWsServer(ws);
 
-    return { ws, mcpServer };
+    return { ws, mcpServer, tunnelWs };
   }
 
   while (true) {
-    let connection: { ws: WebSocket; mcpServer: McpServerService } | null =
-      null;
+    let connection: {
+      ws: WebSocket;
+      mcpServer: McpServerService;
+      tunnelWs: WebSocket | null;
+    } | null = null;
 
     if (!connected) {
       console.log("Attempting to connect...");

package/src/workers/tools/index.ts

@@ -0,0 +1,10 @@
+export * from "./listAllowedPorts";
+import {
+  listAllowedPorts,
+  listAllowedPortsDefinition,
+} from "./listAllowedPorts";
+
+export default {
+  tools: { listAllowedPorts },
+  definitions: [listAllowedPortsDefinition],
+};

package/src/workers/tools/listAllowedPorts.ts

@@ -0,0 +1,30 @@
+import { getConfig } from "../../config";
+import { Tool } from "../../clients/types";
+
+/**
+ * Tool to list all forwarded ports configured for the worker tunnel
+ * This reads from the worker.tunnel.allowedPorts configuration
+ */
+export async function listAllowedPorts(): Promise<number[]> {
+  const config = await getConfig();
+
+  if (!config.worker?.tunnel?.enabled) {
+    return [];
+  }
+
+  return config.worker.tunnel.allowedPorts || [];
+}
+
+export const listAllowedPortsDefinition: Tool = {
+  type: "function" as const,
+  function: {
+    name: "listAllowedPorts",
+    description:
+      "List all ports that are being forwarded through the worker tunnel. Returns an array of port numbers that can be accessed via the tunnel system.",
+    parameters: {
+      type: "object",
+      properties: {},
+      required: [],
+    },
+  },
+};

package/ts_build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tyvm/knowhow",
-    "version": "0.0.64",
+    "version": "0.0.66",
     "description": "ai cli with plugins and agents",
     "main": "ts_build/src/index.js",
     "bin": {
@@ -40,6 +40,7 @@
     "dependencies": {
         "@anthropic-ai/sdk": "^0.39.0",
         "@aws-sdk/client-s3": "^3.588.0",
+        "@tyvm/knowhow-tunnel": "^0.0.1",
         "@google/genai": "^0.14.1",
         "@inquirer/editor": "^4.2.18",
         "@linear/sdk": "^12.0.0",