@tyvm/knowhow 0.0.158 → 0.0.160

package/src/workers/auth/authMiddleware.ts

@@ -1,104 +0,0 @@
-import { WebSocket } from "ws";
-import { WorkerPasskeyAuthService } from "./WorkerPasskeyAuth";
-import { WsMiddlewareFn } from "./WsMiddleware";
-
-/**
- * WebSocket middleware that gates all messages behind passkey auth.
- *
- * This middleware is applied to the TUNNEL WebSocket only — NOT the worker
- * MCP WebSocket. The MCP path keeps the existing unlock/lock tool-based approach.
- *
- * Auth protocol (out-of-band, not MCP):
- *
- *   Client → Worker:  { type: "auth:getChallenge" }
- *   Worker → Client:  { type: "auth:challenge", challenge: "<base64url>", credentialId: "..." }
- *   Client → Worker:  { type: "auth:response", challenge, signature, credentialId,
- *                        authenticatorData, clientDataJSON }
- *   Worker → Client:  { type: "auth:success", expiresAt: "<iso>" }
- *                  or { type: "auth:failure", reason: "..." }
- *
- * While locked, all non-auth messages receive { type: "auth:locked" }.
- * Once unlocked, isLocked() is re-checked on every message to enforce session expiry.
- *
- * The authService passed here is the SAME singleton used by the MCP unlock tool,
- * so unlocking via either path opens both the tunnel and MCP tool access.
- */
-export function makeAuthMiddleware(
-  authService: WorkerPasskeyAuthService
-): WsMiddlewareFn {
-  return async (ws: WebSocket, data: Buffer | string, next) => {
-    // Re-check on every message to enforce session expiry
-    if (!authService.isLocked()) {
-      return next();
-    }
-
-    // Parse the raw message
-    let parsed: any;
-    try {
-      const raw = typeof data === "string" ? data : data.toString("utf-8");
-      parsed = JSON.parse(raw);
-    } catch {
-      ws.send(
-        JSON.stringify({
-          type: "auth:locked",
-          message: "Worker is locked. Send { type: 'auth:getChallenge' } first.",
-        })
-      );
-      return; // don't call next()
-    }
-
-    // auth:getChallenge — issue a challenge
-    if (parsed.type === "auth:getChallenge") {
-      const challenge = authService.generateChallenge();
-      ws.send(
-        JSON.stringify({
-          type: "auth:challenge",
-          challenge,
-          credentialId: authService.getCredentialId(),
-          timestamp: Math.floor(Date.now() / 1000),
-        })
-      );
-      return;
-    }
-
-    // auth:response — verify the assertion
-    if (parsed.type === "auth:response") {
-      const result = await authService.unlock({
-        signature: parsed.signature,
-        credentialId: parsed.credentialId,
-        authenticatorData: parsed.authenticatorData,
-        clientDataJSON: parsed.clientDataJSON,
-        challenge: parsed.challenge,
-      });
-
-      if (result.success) {
-        const info = authService.getSessionInfo();
-        ws.send(
-          JSON.stringify({
-            type: "auth:success",
-            expiresAt: info.expiresAt,
-          })
-        );
-      } else {
-        ws.send(
-          JSON.stringify({
-            type: "auth:failure",
-            reason: result.reason ?? "unknown",
-          })
-        );
-      }
-      // Auth protocol message — don't pass to tunnel handler
-      return;
-    }
-
-    // Any other message while locked — block it
-    ws.send(
-      JSON.stringify({
-        type: "auth:locked",
-        message:
-          "Worker is locked. Send { type: 'auth:getChallenge' } to authenticate.",
-      })
-    );
-    // don't call next()
-  };
-}

package/src/workers/auth/types.ts

@@ -1,70 +0,0 @@
-/**
- * Auth message types for the worker WebSocket authentication protocol.
- */
-
-// Client → Worker: request a challenge
-export interface AuthGetChallengeMessage {
-  type: "auth:getChallenge";
-}
-
-// Worker → Client: sent when a non-auth message is received while locked
-export interface AuthLockedMessage {
-  type: "auth:locked";
-  message: string;
-}
-
-// Worker → Client: challenge
-export interface AuthChallengeMessage {
-  type: "auth:challenge";
-  challenge: string;   // base64-encoded 32 random bytes
-  timestamp: number;   // epoch seconds
-}
-
-// Client → Worker: response
-export interface AuthResponseMessage {
-  type: "auth:response";
-  challenge: string;            // echo back
-  signature: string;            // base64-encoded WebAuthn assertion signature
-  credentialId: string;         // base64-encoded credential ID
-  authenticatorData: string;    // base64-encoded authenticator data
-  clientDataJSON: string;       // base64-encoded client data JSON
-}
-
-// Worker → Client: success
-export interface AuthSuccessMessage {
-  type: "auth:success";
-  token: string;       // opaque session token
-  expiresAt: number;   // epoch seconds
-}
-
-// Worker → Client: failure
-export interface AuthFailureMessage {
-  type: "auth:failure";
-  reason: "invalid_signature" | "expired" | "unknown_credential";
-}
-export type AuthMessage =
-  | AuthGetChallengeMessage
-  | AuthChallengeMessage
-  | AuthResponseMessage
-  | AuthSuccessMessage
-  | AuthFailureMessage
-  | AuthLockedMessage;
-
-// Passkey credential stored in config
-export interface PasskeyCredential {
-  publicKey: string;     // base64-encoded public key
-  credentialId: string;  // base64-encoded credential ID
-  algorithm: string;     // e.g. "ES256"
-}
-
-// Setup session returned by knowhow-web
-export interface PasskeySetupSession {
-  sessionId: string;
-  browserUrl: string;
-}
-
-// Status of a passkey setup session
-export interface PasskeySetupStatus {
-  status: "pending" | "complete" | "expired";
-  credential?: PasskeyCredential;
-}

package/src/workers/tools/getChallenge.ts

@@ -1,33 +0,0 @@
-import { Tool } from "../../clients/types";
-import { WorkerPasskeyAuthService } from "../auth/WorkerPasskeyAuth";
-
-/**
- * Returns a challenge for the client to sign with their passkey.
- * The challenge must be signed and passed to the `unlock` tool.
- */
-export function makeGetChallengeTool(authService: WorkerPasskeyAuthService) {
-  async function getChallenge(): Promise<{ challenge: string; message: string }> {
-    const challenge = authService.generateChallenge();
-    return {
-      challenge,
-      message:
-        "Sign this challenge with your passkey and call the `unlock` tool with the assertion data.",
-    };
-  }
-
-  const getChallengeDefinition: Tool = {
-    type: "function" as const,
-    function: {
-      name: "getChallenge",
-      description:
-        "Get a challenge string to sign with your passkey. Required before calling `unlock`. Returns a base64url-encoded challenge.",
-      parameters: {
-        type: "object",
-        properties: {},
-        required: [],
-      },
-    },
-  };
-
-  return { getChallenge, getChallengeDefinition };
-}

package/src/workers/tools/index.ts

@@ -1,20 +0,0 @@
-export * from "./listAllowedPorts";
-export * from "./getChallenge";
-export * from "./unlock";
-export * from "./lock";
-export * from "./reloadConfig";
-
-import {
-  listAllowedPorts,
-  listAllowedPortsDefinition,
-} from "./listAllowedPorts";
-
-export { makeGetChallengeTool } from "./getChallenge";
-export { makeUnlockTool } from "./unlock";
-export { makeLockTool } from "./lock";
-export { makeReloadConfigTool } from "./reloadConfig";
-
-export default {
-  tools: { listAllowedPorts },
-  definitions: [listAllowedPortsDefinition],
-};

package/src/workers/tools/listAllowedPorts.ts

@@ -1,30 +0,0 @@
-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/src/workers/tools/lock.ts

@@ -1,31 +0,0 @@
-import { Tool } from "../../clients/types";
-import { WorkerPasskeyAuthService } from "../auth/WorkerPasskeyAuth";
-
-/**
- * Re-locks the worker, requiring passkey authentication again for further tool access.
- */
-export function makeLockTool(authService: WorkerPasskeyAuthService) {
-  async function lock(): Promise<{ success: boolean; message: string }> {
-    authService.lock();
-    return {
-      success: true,
-      message: "Worker locked. Call getChallenge and unlock to regain access.",
-    };
-  }
-
-  const lockDefinition: Tool = {
-    type: "function" as const,
-    function: {
-      name: "lock",
-      description:
-        "Lock the worker. After locking, only getChallenge, unlock, and lock tools will be accessible until the worker is unlocked again with a valid passkey assertion.",
-      parameters: {
-        type: "object",
-        properties: {},
-        required: [],
-      },
-    },
-  };
-
-  return { lock, lockDefinition };
-}

package/src/workers/tools/reloadConfig.ts

@@ -1,84 +0,0 @@
-import { Tool } from "../../clients/types";
-import { getConfig } from "../../config";
-import { McpServerService } from "../../services/McpServer";
-import { McpService } from "../../services/Mcp";
-import { ToolsService } from "../../services/Tools";
-
-export interface ReloadConfigResult {
-  success: boolean;
-  toolCount: number;
-  mcpCount: number;
-  message: string;
-}
-
-/**
- * Factory that creates the reloadConfig tool with access to runtime services.
- * The tool re-reads the config from disk, reconnects all MCPs, and rebuilds
- * the active tool list — the same logic as the WebSocket reloadConfig handler.
- *
- * Typical usage after pulling updated config from the cloud worker API:
- *   1. execCommand("knowhow cloudworker --pull <cloudWorkerId>")
- *   2. reloadConfig()
- */
-export function makeReloadConfigTool(
-  Mcp: McpService,
-  Tools: ToolsService,
-  mcpServer: McpServerService,
-  setToolsToUse: (tools: ReturnType<typeof Tools.getToolsByNames>) => void
-) {
-  const reloadConfig = async (): Promise<ReloadConfigResult> => {
-    try {
-      // Re-read fresh config from disk
-      const freshConfig = await getConfig();
-
-      // Close all existing MCP connections
-      await Mcp.closeAll();
-
-      // Reconnect from fresh config and re-register tools
-      await Mcp.connectToConfigured(Tools);
-
-      // Rebuild the allowed tools list from fresh config
-      const allowedToolNames =
-        freshConfig.worker?.allowedTools ?? Tools.getToolNames();
-      const newToolsToUse = Tools.getToolsByNames(allowedToolNames);
-      setToolsToUse(newToolsToUse);
-
-      // Update the MCP server with the new tool list
-      mcpServer.withTools(newToolsToUse);
-
-      const mcpCount = freshConfig.mcps?.length ?? 0;
-
-      return {
-        success: true,
-        toolCount: newToolsToUse.length,
-        mcpCount,
-        message: `Config reloaded: ${newToolsToUse.length} tools active, ${mcpCount} MCP(s) configured`,
-      };
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      return {
-        success: false,
-        toolCount: 0,
-        mcpCount: 0,
-        message: `Failed to reload config: ${message}`,
-      };
-    }
-  };
-
-  const reloadConfigDefinition: Tool = {
-    type: "function" as const,
-    function: {
-      name: "reloadConfig",
-      description:
-        "Reload the worker config from disk, reconnect all MCPs, and rebuild the active tool list. " +
-        "Call this after running `knowhow cloudworker --pull <id>` to apply updated MCPs without restarting the worker.",
-      parameters: {
-        type: "object",
-        properties: {},
-        required: [],
-      },
-    },
-  };
-
-  return { reloadConfig, reloadConfigDefinition };
-}

package/src/workers/tools/unlock.ts

@@ -1,116 +0,0 @@
-import { Tool } from "../../clients/types";
-import { WorkerPasskeyAuthService } from "../auth/WorkerPasskeyAuth";
-
-export interface UnlockToolParams {
-  /** base64url-encoded signature from WebAuthn assertion */
-  signature?: string;
-  /** base64url-encoded credential ID */
-  credentialId?: string;
-  /** base64url-encoded authenticatorData */
-  authenticatorData?: string;
-  /** base64url-encoded clientDataJSON */
-  clientDataJSON?: string;
-  /** The challenge that was signed (base64url) */
-  challenge?: string;
-}
-
-/**
- * Combined challenge+unlock tool.
- *
- * - Called with NO params (or missing assertion fields): generates and returns a challenge.
- * - Called WITH all assertion fields: verifies the WebAuthn assertion and unlocks the worker.
- *
- * This two-step flow lets the frontend call the tool once to get a challenge,
- * do the browser WebAuthn assertion, then call again with the signed data.
- */
-export function makeUnlockTool(authService: WorkerPasskeyAuthService) {
-  async function unlock(
-    params: UnlockToolParams = {}
-  ): Promise<{ success: boolean; message: string; challenge?: string; credentialId?: string }> {
-    const hasAssertion =
-      params.signature &&
-      params.credentialId &&
-      params.authenticatorData &&
-      params.clientDataJSON &&
-      params.challenge;
-
-    // Step 1: no assertion data → generate and return a challenge
-    if (!hasAssertion) {
-      const challenge = authService.generateChallenge();
-      return {
-        success: false,
-        challenge,
-        credentialId: authService.getCredentialId(),
-        message:
-          "Sign this challenge with your passkey and call unlock again with the assertion data.",
-      };
-    }
-
-    // Step 2: verify assertion and unlock
-    const result = await authService.unlock({
-      signature: params.signature!,
-      credentialId: params.credentialId!,
-      authenticatorData: params.authenticatorData!,
-      clientDataJSON: params.clientDataJSON!,
-      challenge: params.challenge!,
-    });
-
-    if (result.success) {
-      const info = authService.getSessionInfo();
-      return {
-        success: true,
-        message: `Worker unlocked successfully. Session expires at ${info.expiresAt}.`,
-      };
-    }
-
-    return {
-      success: false,
-      message: `Unlock failed: ${result.reason}`,
-    };
-  }
-
-  const unlockDefinition: Tool = {
-    type: "function" as const,
-    function: {
-      name: "unlock",
-      description:
-        "Unlock the worker using a passkey. " +
-        "Call with NO parameters to receive a challenge string. " +
-        "Then sign the challenge via the browser WebAuthn API (navigator.credentials.get) and call again with the assertion data to unlock. " +
-        "All other tools are blocked until the worker is unlocked.",
-      parameters: {
-        type: "object",
-        properties: {
-          signature: {
-            type: "string",
-            description:
-              "base64url-encoded signature from WebAuthn assertion response.signature",
-          },
-          credentialId: {
-            type: "string",
-            description:
-              "base64url-encoded credential ID from WebAuthn assertion",
-          },
-          authenticatorData: {
-            type: "string",
-            description:
-              "base64url-encoded authenticatorData from WebAuthn assertion response.authenticatorData",
-          },
-          clientDataJSON: {
-            type: "string",
-            description:
-              "base64url-encoded clientDataJSON from WebAuthn assertion response.clientDataJSON",
-          },
-          challenge: {
-            type: "string",
-            description:
-              "The challenge string returned by the first unlock() call (base64url)",
-          },
-        },
-        required: [],
-      },
-    },
-  };
-
-  return { unlock, unlockDefinition };
-}