too-many-claw 1.0.21 → 1.0.23

package/dist/cli.js

@@ -1475,6 +1475,25 @@ var ConfigManager = class {
   getOpenClawConfigPath() {
     return this.openclawConfigPath;
   }
+  /**
+   * Get the OpenClaw Gateway authentication token
+   * First checks environment variable OPENCLAW_GATEWAY_TOKEN,
+   * then falls back to openclaw.json gateway.token or gateway.password
+   */
+  getGatewayToken() {
+    const envToken = process.env.OPENCLAW_GATEWAY_TOKEN;
+    if (envToken) {
+      return envToken;
+    }
+    const config = this.readOpenClawConfig();
+    if (config?.gateway?.token) {
+      return config.gateway.token;
+    }
+    if (config?.gateway?.password) {
+      return config.gateway.password;
+    }
+    return void 0;
+  }
   // ============================================
   // Validation & Repair
   // ============================================
@@ -2330,6 +2349,7 @@ import WebSocket from "ws";
 import { EventEmitter } from "events";
 var DEFAULT_CONFIG2 = {
   url: "ws://127.0.0.1:18789",
+  gatewayToken: "",
   reconnect: {
     enabled: true,
     maxAttempts: 10,
@@ -2337,7 +2357,8 @@ var DEFAULT_CONFIG2 = {
     maxDelay: 3e4
   },
   heartbeatInterval: 3e4,
-  connectionTimeout: 1e4
+  connectionTimeout: 1e4,
+  verbose: false
 };
 function extractTextContent(content) {
   if (!content) {
@@ -2503,6 +2524,10 @@ var GatewayClient = class extends EventEmitter {
       return;
     }
     this.emit("message", message);
+    if (message.type === "event" && message.event === "connect.challenge") {
+      this.handleConnectChallenge(message);
+      return;
+    }
     const roleBasedMessage = message;
     if (roleBasedMessage.role) {
       this.handleRoleBasedMessage(roleBasedMessage);
@@ -2701,6 +2726,43 @@ var GatewayClient = class extends EventEmitter {
       this.heartbeatTimer = null;
     }
   }
+  /**
+   * Handle OpenClaw Gateway connect.challenge event
+   * Responds with authentication token to complete connection handshake
+   */
+  handleConnectChallenge(message) {
+    const payload = message.payload || {};
+    const nonce = payload.nonce;
+    const ts = payload.ts;
+    this.log(`Received connect.challenge (nonce: ${nonce?.substring(0, 8)}...)`);
+    if (!this.config.gatewayToken) {
+      this.log("Warning: No gateway token configured, authentication may fail");
+    }
+    const connectResponse = {
+      type: "connect",
+      token: this.config.gatewayToken,
+      nonce,
+      ts,
+      client: {
+        name: "too-many-claw",
+        version: "1.0.0"
+      }
+    };
+    const sent = this.send(connectResponse);
+    if (sent) {
+      this.log("Sent connect response with authentication token");
+    } else {
+      this.log("Failed to send connect response");
+    }
+  }
+  /**
+   * Log message if verbose mode is enabled
+   */
+  log(message) {
+    if (this.config.verbose) {
+      console.log(`[GatewayClient] ${message}`);
+    }
+  }
 };
 
 // src/discord/BotMessageMonitor.ts
@@ -2817,7 +2879,8 @@ var BotMessageMonitor = class extends EventEmitter2 {
       agentId,
       timestamp: Date.now()
     });
-    this.log(`Registered pending message for agent ${agentId}: ${content.substring(0, 50)}...`);
+    this.forceLog(`\u{1F4DD} Registered pending: ${agentId} \u2192 "${content.substring(0, 40)}..."`);
+    this.log(`  Hash: ${hash.substring(0, 50)}`);
     this.cleanupPendingMessages();
   }
   /**
@@ -2851,9 +2914,12 @@ var BotMessageMonitor = class extends EventEmitter2 {
   lookupPendingAgent(content) {
     const hash = this.hashContent(content);
     const pending = this.pendingMessages.get(hash);
+    this.log(`Looking up agent for content: "${content.substring(0, 40)}..."`);
+    this.log(`  Generated hash: ${hash.substring(0, 50)}`);
+    this.log(`  Pending messages count: ${this.pendingMessages.size}`);
     if (pending && Date.now() - pending.timestamp < this.PENDING_MESSAGE_TTL) {
       this.pendingMessages.delete(hash);
-      this.log(`Found pending agent ${pending.agentId} for message`);
+      this.forceLog(`\u2713 Found pending agent ${pending.agentId} via exact hash match`);
       return pending.agentId;
     }
     const normalizedContent = content.trim().toLowerCase();
@@ -2862,11 +2928,17 @@ var BotMessageMonitor = class extends EventEmitter2 {
       if (normalizedContent.includes(pendingContent.substring(0, 100)) || pendingContent.includes(normalizedContent.substring(0, 100))) {
         if (Date.now() - data.timestamp < this.PENDING_MESSAGE_TTL) {
           this.pendingMessages.delete(pendingHash);
-          this.log(`Found pending agent ${data.agentId} via partial match`);
+          this.forceLog(`\u2713 Found pending agent ${data.agentId} via partial match`);
           return data.agentId;
         }
       }
     }
+    if (this.pendingMessages.size > 0) {
+      this.log(`No match found. Current pending messages:`);
+      for (const [pendingHash, data] of this.pendingMessages) {
+        this.log(`  - ${data.agentId}: ${pendingHash.substring(0, 50)}...`);
+      }
+    }
     return null;
   }
   /**
@@ -2928,12 +3000,12 @@ var BotMessageMonitor = class extends EventEmitter2 {
       if (pendingAgentId) {
         agent = this.agentMapper.resolve(pendingAgentId) || this.agentMapper.getDefaultAgent();
         cleanContent = message.content;
-        this.log(`Using agent ${agent.id} from Gateway event`);
+        this.forceLog(`\u2192 Using agent ${agent.emoji} ${agent.name} from Gateway event`);
       } else {
         const extracted = this.extractAgentFromContent(message.content);
         agent = extracted.agent;
         cleanContent = extracted.cleanContent;
-        this.log(`Using agent ${agent.id} from content extraction (fallback)`);
+        this.forceLog(`\u2192 Using agent ${agent.emoji} ${agent.name} from content extraction (fallback)`);
       }
       this.emit("intercepted", message.id, message.channel.id, agent.id);
       this.forceLog(`\u{1F980} Intercepted message \u2192 ${agent.emoji} ${agent.name}`);
@@ -3086,6 +3158,10 @@ var AgentMapper = class {
       this.idMap.set(agent.id.toLowerCase(), agent);
       const normalizedName = this.normalizeName(agent.name);
       this.nameMap.set(normalizedName, agent);
+      const openClawName = `${agent.emoji} ${agent.name}`.toLowerCase();
+      this.nameMap.set(openClawName, agent);
+      this.nameMap.set(this.normalizeName(openClawName), agent);
+      this.aliasMap.set(agent.emoji, agent);
       this.buildAliases(agent);
     }
   }
@@ -3136,9 +3212,18 @@ var AgentMapper = class {
     if (!identifier) {
       return this.getDefaultAgent();
     }
-    const normalized = identifier.toLowerCase().trim();
+    let cleanIdentifier = identifier.trim();
+    const emojiMatch = cleanIdentifier.match(/^([\p{Emoji}])\s*/u);
+    if (emojiMatch) {
+      const emoji = emojiMatch[1];
+      const byEmoji = this.aliasMap.get(emoji);
+      if (byEmoji) return byEmoji;
+    }
+    const normalized = cleanIdentifier.toLowerCase().trim();
     const byId = this.idMap.get(normalized);
     if (byId) return byId;
+    const byOpenClawName = this.nameMap.get(normalized);
+    if (byOpenClawName) return byOpenClawName;
     const byName = this.nameMap.get(this.normalizeName(identifier));
     if (byName) return byName;
     const byAlias = this.aliasMap.get(normalized);
@@ -3223,8 +3308,14 @@ var OpenClawDaemon = class extends EventEmitter3 {
     this.configManager = new ConfigManager();
     this.webhookManager = new WebhookManager();
     this.agentMapper = new AgentMapper();
+    const gatewayToken = this.configManager.getGatewayToken();
+    if (!gatewayToken) {
+      this.forceLog("Warning: No gateway token found. Set OPENCLAW_GATEWAY_TOKEN env var or configure in openclaw.json");
+    }
     this.gatewayClient = new GatewayClient({
       url: this.config.gatewayUrl,
+      gatewayToken,
+      verbose: this.config.verbose,
       reconnect: {
         enabled: true,
         maxAttempts: -1,
@@ -3453,9 +3544,12 @@ var OpenClawDaemon = class extends EventEmitter3 {
    */
   registerPendingMessageForMonitor(message) {
     if (!this.botMessageMonitor) return;
-    const agentIdentifier = message.agentId || message.agentName || message.agent || message.name;
+    const agentIdentifier = this.extractAgentIdentifier(message);
     const agent = this.agentMapper.resolve(agentIdentifier);
     const agentId = agent?.id || "base";
+    if (this.config.verbose) {
+      this.log(`registerPendingMessageForMonitor - identifier: ${agentIdentifier}, resolved to: ${agentId}`);
+    }
     let content = "";
     if (typeof message.content === "string") {
       content = message.content;
@@ -3487,6 +3581,15 @@ var OpenClawDaemon = class extends EventEmitter3 {
       if (message.stream) {
         this.log(`  Stream: ${message.stream}`);
       }
+      if (message.agentId) {
+        this.log(`  AgentId: ${message.agentId}`);
+      }
+      if (message.runId) {
+        this.log(`  RunId: ${message.runId}`);
+      }
+      if (message.data) {
+        this.log(`  Data keys: ${Object.keys(message.data).join(", ")}`);
+      }
     }
   }
   /**
@@ -3495,7 +3598,10 @@ var OpenClawDaemon = class extends EventEmitter3 {
    * because the message_sent event handler will intercept and resend via webhook.
    */
   async handleAgentResponse(message) {
-    const agentIdentifier = message.agentId || message.agentName || message.agent || message.name;
+    const agentIdentifier = this.extractAgentIdentifier(message);
+    if (this.config.verbose) {
+      this.log(`Agent response - extracted identifier: ${agentIdentifier}`);
+    }
     let content = "";
     if (typeof message.content === "string") {
       content = message.content;
@@ -3517,11 +3623,43 @@ var OpenClawDaemon = class extends EventEmitter3 {
     }
     await this.forwardToWebhook(agent, content);
   }
+  /**
+   * Extract agent identifier from OpenClaw Gateway message
+   * Checks multiple fields since OpenClaw may send agent info in different places
+   */
+  extractAgentIdentifier(message) {
+    if (message.agentId) return message.agentId;
+    if (message.agentName) return message.agentName;
+    if (message.agent) return message.agent;
+    if (message.name) return message.name;
+    const data = message.data;
+    if (data) {
+      if (data.agentId) return data.agentId;
+      if (data.agentName) return data.agentName;
+      if (data.agent) return data.agent;
+      if (data.name) return data.name;
+    }
+    const runId = message.id || message.runId;
+    if (runId && typeof runId === "string") {
+      const runIdMatch = runId.match(/^([a-z][a-z0-9-]*)-[a-z0-9]+$/i);
+      if (runIdMatch) {
+        const potentialAgent = runIdMatch[1];
+        if (this.agentMapper.resolve(potentialAgent)) {
+          return potentialAgent;
+        }
+      }
+    }
+    if (this.config.verbose) {
+      this.log(`Could not extract agent from message. Keys: ${Object.keys(message).join(", ")}`);
+      this.log(`  Full message: ${JSON.stringify(message).substring(0, 300)}`);
+    }
+    return "assistant";
+  }
   /**
    * Handle streaming delta (partial response)
    */
   handleAgentDelta(message) {
-    const agentIdentifier = message.agentId || message.agentName || message.agent || "assistant";
+    const agentIdentifier = this.extractAgentIdentifier(message);
     let delta = "";
     if (typeof message.delta === "string") {
       delta = message.delta;
@@ -3573,7 +3711,10 @@ var OpenClawDaemon = class extends EventEmitter3 {
    */
   async handleAgentEnd(message) {
     const messageId = message.id || message.runId || message.agentId || message.agentName || "default";
-    const agentIdentifier = message.agentId || message.agentName || message.agent || "assistant";
+    const agentIdentifier = this.extractAgentIdentifier(message);
+    if (this.config.verbose) {
+      this.log(`Agent end - messageId: ${messageId}, extracted identifier: ${agentIdentifier}`);
+    }
     this.log(`Agent end event [${messageId}] from: ${agentIdentifier}`);
     const skipWebhook = this.botMessageMonitor && this.botMessageMonitor.isEnabled();
     const buffered = this.responseBuffers.get(messageId);