@tyvm/knowhow 0.0.158 → 0.0.160

package/src/services/watchers/RemoteSyncer.ts

@@ -1,196 +0,0 @@
-import { Message } from "../../clients/types";
-import { EventService } from "../EventService";
-import * as fs from "fs";
-import * as fsPromises from "fs/promises";
-import * as path from "path";
-import { messagesToRenderEvents } from "../../chat/renderer/messagesToRenderEvents";
-import { KnowhowSimpleClient } from "../KnowhowClient";
-import { SyncedAgentWatcher } from "../SyncedAgentWatcher";
-
-/**
- * Watches an agent running on Knowhow Web via polling the API.
- * Polls GET /tasks/<taskId> every 3 seconds for thread updates.
- * Sends messages via the client's sendMessageToAgent method.
- */
-export class WebSyncedAgentWatcher implements SyncedAgentWatcher {
-  public taskId: string = "";
-  private client: KnowhowSimpleClient;
-  private pollInterval: NodeJS.Timeout | null = null;
-  private lastThreadIndex: number = -1;
-  private lastThreadLength: number = 0;
-  private lastMessageJson: string | null = null;
-  public agentName: string = "remote-agent";
-  private stopped: boolean = false;
-  public agentEvents = new EventService();
-  public eventTypes = {
-    done: "done",
-    toolCall: "tool:pre_call",
-    toolUsed: "tool:post_call",
-    agentSay: "agent:say",
-    threadUpdate: "thread_update",
-  };
-
-  constructor(client?: KnowhowSimpleClient) {
-    this.client = client || new KnowhowSimpleClient();
-  }
-
-  async startWatching(taskId: string): Promise<void> {
-    this.taskId = taskId;
-    this.stopped = false;
-
-    // Load initial state to track current thread length
-    try {
-      const details = await this.client.getTaskDetails(taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      this.lastThreadIndex = threads.length - 1;
-      this.agentName = "remote-agent";
-      this.lastThreadLength = lastThread.length;
-      this.lastMessageJson = this.messageJson(lastThread[lastThread.length - 1]);
-    } catch (err: any) {
-      console.warn(
-        `⚠️  Could not load initial state for task ${taskId}: ${err.message}`
-      );
-    }
-
-    // Poll every 3 seconds for updates
-    this.pollInterval = setInterval(async () => {
-      if (!this.stopped) {
-        await this.onPoll().catch(() => {});
-      }
-    }, 3000);
-
-    console.log(`🌐 Watching web-synced agent: ${taskId} (${this.agentName})`);
-    console.log(
-      `   Type /logs 20 to see recent messages, or type to send a message`
-    );
-  }
-
-  private async onPoll(): Promise<void> {
-    if (this.stopped) return;
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      const threads: any[][] = details?.data?.threads || [];
-      const lastThread = threads[threads.length - 1] || [];
-      const threadIndex = threads.length - 1;
-
-      let newMessages: any[];
-      if (
-        threadIndex === this.lastThreadIndex &&
-        lastThread.length >= this.lastThreadLength
-      ) {
-        newMessages = lastThread.slice(this.lastThreadLength);
-      } else {
-        const retainedIndex = this.findLastMessage(
-          lastThread,
-          this.lastMessageJson
-        );
-        newMessages = lastThread.slice(retainedIndex + 1);
-      }
-
-      this.lastThreadIndex = threadIndex;
-      this.lastThreadLength = lastThread.length;
-      this.lastMessageJson = this.messageJson(lastThread[lastThread.length - 1]);
-
-      if (newMessages.length > 0) {
-        const renderEvents = messagesToRenderEvents(
-          newMessages,
-          this.taskId,
-          this.agentName
-        );
-        for (const event of renderEvents) {
-          if (event.type === "toolCall") {
-            this.agentEvents.emit(this.eventTypes.toolCall, {
-              toolCall: (event as any).toolCall,
-            });
-          } else if (event.type === "toolResult") {
-            this.agentEvents.emit(this.eventTypes.toolUsed, {
-              toolCall: (event as any).toolCall,
-              functionResp: (event as any).result,
-            });
-          } else if (event.type === "agentMessage") {
-            this.agentEvents.emit(this.eventTypes.agentSay, {
-              message: (event as any).message,
-            });
-          }
-        }
-        this.agentEvents.emit(this.eventTypes.threadUpdate, lastThread);
-      }
-
-      // Stop polling and emit done if task is complete with a result
-      const status = details?.data?.status;
-      const result = details?.data?.result;
-      if (status === "completed" || status === "killed") {
-        this.stopWatching();
-        if (result != null) {
-          this.agentEvents.emit(this.eventTypes.done, result);
-        } else {
-          console.log(
-            `\n✅ Remote agent ${this.taskId} status: ${status} (no result)`
-          );
-        }
-      }
-    } catch {
-      // Silently continue on poll errors
-    }
-  }
-
-  async sendMessage(message: string): Promise<void> {
-    await this.client.sendMessageToAgent(this.taskId, message);
-  }
-
-  async getThreads(): Promise<any[][]> {
-    try {
-      const details = await this.client.getTaskDetails(this.taskId);
-      return details?.data?.threads || [];
-    } catch {
-      return [];
-    }
-  }
-
-  stopWatching(): void {
-    this.stopped = true;
-    if (this.pollInterval) {
-      clearInterval(this.pollInterval);
-      this.pollInterval = null;
-    }
-    console.log(`🔌 Stopped watching web agent: ${this.taskId}`);
-  }
-
-  async pause(): Promise<void> {
-    await this.client.pauseAgent(this.taskId);
-    console.log(`⏸️  Paused remote web agent: ${this.taskId}`);
-  }
-
-  async unpause(): Promise<void> {
-    await this.client.resumeAgent(this.taskId);
-    console.log(`▶️  Unpaused remote web agent: ${this.taskId}`);
-  }
-
-  async kill(): Promise<void> {
-    await this.client.killAgent(this.taskId);
-    console.log(`🛑 Killed remote web agent: ${this.taskId}`);
-  }
-
-  async interrupt(message?: string): Promise<void> {
-    await this.client.sendMessageToAgent(this.taskId, `/poke ${message || ""}`.trim());
-    console.log(`🫵 Interrupt sent to remote web agent: ${this.taskId}`);
-  }
-
-  private messageJson(message: any): string | null {
-    if (message == null) return null;
-    try {
-      return JSON.stringify(message);
-    } catch {
-      return null;
-    }
-  }
-
-  private findLastMessage(messages: any[], messageJson: string | null): number {
-    if (messageJson == null) return -1;
-    for (let index = messages.length - 1; index >= 0; index--) {
-      if (this.messageJson(messages[index]) === messageJson) return index;
-    }
-    return -1;
-  }
-}

package/src/services/watchers/index.ts

@@ -1,2 +0,0 @@
-export * from "./FsSyncer";
-export * from "./RemoteSyncer";

package/src/tunnel.ts

@@ -1,243 +0,0 @@
-import os from "os";
-import { WebSocket } from "ws";
-import { createTunnelHandler, TunnelHandler } from "@tyvm/knowhow-tunnel";
-import { loadJwt } from "./login";
-import { wait } from "./utils";
-import { getConfig } from "./config";
-import { KNOWHOW_API_URL } from "./services/KnowhowClient";
-import { ModulesService } from "./services/modules";
-import { WorkerPasskeyAuthService } from "./workers/auth/WorkerPasskeyAuth";
-import { WsMiddlewareStack } from "./workers/auth/WsMiddleware";
-import { makeAuthMiddleware } from "./workers/auth/authMiddleware";
-
-const PROD_TUNNEL_WORKER_DOMAIN = "worker.tyvm-apps.com";
-
-/**
- * Resolve the tunnel domain and protocol from the environment and API URL.
- * TUNNEL_WORKER_DOMAIN takes precedence. Otherwise localhost API URLs use the
- * local tunnel proxy, dev API URLs use the dev tunnel domain, and all other API
- * URLs use the production tunnel domain.
- */
-export function extractTunnelDomain(apiUrl: string): {
-  domain: string;
-  useHttps: boolean;
-} {
-  try {
-    const url = new URL(apiUrl);
-    const useHttps = url.protocol === "https:";
-    const configuredDomain = process.env.TUNNEL_WORKER_DOMAIN?.trim();
-
-    const isLocalApi =
-      url.hostname === "localhost" ||
-      url.hostname.endsWith(".localhost") ||
-      url.hostname === "127.0.0.1" ||
-      url.hostname === "[::1]";
-    const isDevApi = url.hostname.split(".").includes("dev");
-    const domain =
-      configuredDomain ||
-      (isLocalApi
-        ? `worker.localhost:${url.port || (useHttps ? "443" : "80")}`
-        : isDevApi
-          ? `worker.dev.tyvm-apps.com`
-          : PROD_TUNNEL_WORKER_DOMAIN);
-
-    return { domain, useHttps };
-  } catch (err) {
-    console.error("Failed to parse API_URL for tunnel domain:", err);
-    return {
-      domain:
-        process.env.TUNNEL_WORKER_DOMAIN?.trim() ||
-        PROD_TUNNEL_WORKER_DOMAIN,
-      useHttps: false,
-    };
-  }
-}
-
-/**
- * Initialize a tunnel handler and load tunnel modules.
- */
-export async function initTunnelHandler(
-  tunnelConnection: WebSocket,
-  tunnelConfig: Parameters<typeof createTunnelHandler>[1]
-): Promise<TunnelHandler> {
-  const handler = createTunnelHandler(tunnelConnection, tunnelConfig);
-  console.log("🌐 Tunnel handler initialized");
-  console.log(tunnelConfig);
-
-  const tunnelModuleService = new ModulesService();
-  const tunnelContext = await tunnelModuleService.overrideDefaultContext({
-    Tunnel: handler,
-  });
-  tunnelModuleService.loadModulesFromConfig(tunnelContext).catch((err) => {
-    console.error("Failed to load tunnel modules:", err);
-  });
-
-  return handler;
-}
-
-/**
- * Resolve tunnel local host, log port mapping, and return shared tunnel setup values.
- * Extracted to avoid duplication between worker() and tunnel().
- */
-export function resolveTunnelConfig(
-  config: Awaited<ReturnType<typeof getConfig>>,
-  isInsideDocker: boolean
-): { tunnelLocalHost: string; portMapping: Record<string, number> } {
-  // 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 || {}) as Record<string, number>;
-  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}`);
-    }
-  }
-
-  return { tunnelLocalHost, portMapping };
-}
-
-/**
- * Options for connectTunnelWebSocket helper.
- */
-export interface TunnelWebSocketOptions {
-  /** Already-resolved tunnel domain (hostname only, no protocol) */
-  tunnelDomain: string;
-  /** Whether the tunnel should use HTTPS */
-  tunnelUseHttps: boolean;
-  /** Local host to forward tunnel traffic to */
-  tunnelLocalHost: string;
-  /** Port mapping configuration */
-  portMapping: Record<string, number>;
-  /** Worker config (for tunnel sub-config) */
-  config: Awaited<ReturnType<typeof getConfig>>;
-  /** HTTP headers to attach to the WebSocket upgrade request */
-  headers: Record<string, string>;
-  /** Callback invoked with the TunnelHandler once the connection opens */
-  onOpen?: (handler: TunnelHandler) => void;
-  /** Called when the connection closes; receives code + reason string */
-  onClose?: (code: number, reason: string) => void;
-  /** Called on error */
-  onError?: (error: Error) => void;
-  /** Called when a pong frame is received (liveness heartbeat) */
-  onPong?: () => void;
-  /** Optional passkey auth service — if provided, applies WS middleware to gate tunnel traffic */
-  authService?: WorkerPasskeyAuthService | null;
-}
-
-/**
- * Create a tunnel WebSocket connection, build the tunnelConfig, and
- * initialize the tunnel handler.  Returns the WebSocket.
- *
- * The caller is responsible for storing a reference to the returned TunnelHandler
- * (via onOpen) and performing any outer-state cleanup (via onClose / onError).
- */
-export function connectTunnelWebSocket(
-  options: TunnelWebSocketOptions
-): WebSocket {
-  const {
-    tunnelDomain,
-    tunnelUseHttps,
-    tunnelLocalHost,
-    portMapping,
-    config,
-    headers,
-    onOpen,
-    onClose,
-    onError,
-    onPong,
-    authService,
-  } = options;
-
-  const tunnelConnection = new WebSocket(`${KNOWHOW_API_URL}/ws/tunnel`, { headers });
-
-  tunnelConnection.on("open", async () => {
-    console.log("Tunnel WebSocket connected");
-
-    // Apply passkey auth middleware FIRST, before tunnel handler registers its
-    // "message" listener. Node.js EventEmitter fires listeners in registration
-    // order, so our middleware runs first. wrapSocket() also redirects future
-    // ws.on("message", ...) calls to an inner emitter, ensuring the tunnel
-    // handler only receives messages that passed the middleware.
-    if (authService) {
-      const stack = new WsMiddlewareStack();
-      stack.use(makeAuthMiddleware(authService));
-      stack.wrapSocket(tunnelConnection);
-    }
-
-    const allowedPorts = config.worker?.tunnel?.allowedPorts || [];
-
-    // Create URL rewriter callback that returns the hostname (without protocol).
-    // The tunnel package will add the protocol based on the useHttps config.
-    const urlRewriter = (port: number, metadata?: any) => {
-      const workerId = metadata?.workerId;
-      const secret = metadata?.secret;
-      // Examples: secret-p3000.worker.example.com  /  workerId-p3000.worker.example.com
-      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,
-    };
-
-    const handler = await initTunnelHandler(tunnelConnection, tunnelConfig);
-    onOpen?.(handler);
-  });
-
-  tunnelConnection.on("close", (code, reason) => {
-    console.log(
-      `Tunnel WebSocket closed. Code: ${code}, Reason: ${reason.toString()}`
-    );
-    onClose?.(code, reason.toString());
-  });
-
-  tunnelConnection.on("error", (error) => {
-    console.error("Tunnel WebSocket error:", error);
-    onError?.(error);
-  });
-
-  // Pong watchdog: proves the tunnel socket is genuinely alive (not a
-  // snapshot-resume zombie). The caller sends ws.ping() and requires a pong.
-  if (onPong) {
-    tunnelConnection.on("pong", () => {
-      onPong();
-    });
-  }
-
-  return tunnelConnection;
-}
-
-/**
- * The minimal set of tool names that are always registered when running in
- * tunnel mode. These are the tools the backend and frontend need to interact
- * with the tunnel worker (port discovery, passkey auth).
- *
- * Additional tools can be added here in the future without changing the CLI.
- */
-export const TUNNEL_MINIMAL_TOOLS = [
-  "listAllowedPorts",
-  "unlock",
-  "lock",
-  "reloadConfig",
-];