too-many-claw 1.0.4 → 1.0.6

package/dist/cli.js

@@ -1209,22 +1209,134 @@ var ConfigManager = class {
    */
   hasOpenClawDiscordConfig() {
     const config = this.readOpenClawConfig();
-    return !!config?.gateway?.discord?.token;
+    return !!(config?.gateway?.discord?.token || config?.discord?.token || config?.channels?.discord?.token);
   }
   /**
-   * Get Discord settings from OpenClaw config
+   * Get raw Discord settings from OpenClaw config
    */
   getOpenClawDiscordConfig() {
     const config = this.readOpenClawConfig();
-    return config?.gateway?.discord ?? null;
+    return config?.gateway?.discord ?? config?.channels?.discord ?? config?.discord ?? null;
+  }
+  /**
+   * Parse a channel string that may be in "guildId/channelId" format
+   * Returns { guildId, channelId } or just { channelId } if no slash
+   */
+  parseChannelString(channelStr) {
+    if (channelStr.includes("/")) {
+      const [guildId, channelId] = channelStr.split("/");
+      return { guildId, channelId };
+    }
+    return { channelId: channelStr };
+  }
+  /**
+   * Get the full OpenClaw config for debugging
+   */
+  getOpenClawRawConfig() {
+    return this.readOpenClawConfig();
+  }
+  /**
+   * Extract and normalize Discord settings from OpenClaw config
+   * Returns a clean, normalized structure regardless of how OpenClaw stores it
+   */
+  extractOpenClawDiscordSettings() {
+    const config = this.readOpenClawConfig();
+    if (!config) return null;
+    const discord = this.getOpenClawDiscordConfig();
+    const channelsDiscord = config?.channels?.discord;
+    if (!discord && !channelsDiscord) return null;
+    const settings = {};
+    if (discord?.token) {
+      settings.token = discord.token;
+    }
+    if (discord?.guildId) {
+      settings.guildId = discord.guildId;
+    } else if (discord?.serverId) {
+      settings.guildId = discord.serverId;
+    } else if (discord?.allowlist?.guilds && discord.allowlist.guilds.length > 0) {
+      settings.guildId = discord.allowlist.guilds[0];
+    }
+    if (channelsDiscord?.channel) {
+      const parsed = this.parseChannelString(channelsDiscord.channel);
+      if (parsed.guildId && !settings.guildId) {
+        settings.guildId = parsed.guildId;
+      }
+      if (!settings.chatChannelId) {
+        settings.chatChannelId = parsed.channelId;
+      }
+    }
+    if (channelsDiscord?.channels && channelsDiscord.channels.length > 0) {
+      const parsedChannels = [];
+      for (const ch of channelsDiscord.channels) {
+        parsedChannels.push(this.parseChannelString(ch));
+      }
+      if (!settings.guildId && parsedChannels[0]?.guildId) {
+        settings.guildId = parsedChannels[0].guildId;
+      }
+      if (!settings.chatChannelId && parsedChannels[0]) {
+        settings.chatChannelId = parsedChannels[0].channelId;
+      }
+      if (!settings.statusChannelId && parsedChannels[1]) {
+        settings.statusChannelId = parsedChannels[1].channelId;
+      }
+      settings.allowedChannels = parsedChannels.map((p) => p.channelId);
+    }
+    if (discord?.channels?.chat) {
+      const parsed = this.parseChannelString(discord.channels.chat);
+      if (parsed.guildId && !settings.guildId) {
+        settings.guildId = parsed.guildId;
+      }
+      if (!settings.chatChannelId) {
+        settings.chatChannelId = parsed.channelId;
+      }
+    } else if (discord?.channels?.default) {
+      const parsed = this.parseChannelString(discord.channels.default);
+      if (parsed.guildId && !settings.guildId) {
+        settings.guildId = parsed.guildId;
+      }
+      if (!settings.chatChannelId) {
+        settings.chatChannelId = parsed.channelId;
+      }
+    }
+    if (discord?.allowlist?.channels && discord.allowlist.channels.length > 0) {
+      const parsedChannels = [];
+      for (const ch of discord.allowlist.channels) {
+        parsedChannels.push(this.parseChannelString(ch));
+      }
+      if (!settings.guildId && parsedChannels[0]?.guildId) {
+        settings.guildId = parsedChannels[0].guildId;
+      }
+      if (!settings.chatChannelId && parsedChannels[0]) {
+        settings.chatChannelId = parsedChannels[0].channelId;
+      }
+      if (!settings.statusChannelId && parsedChannels[1]) {
+        settings.statusChannelId = parsedChannels[1].channelId;
+      }
+      if (!settings.allowedChannels) {
+        settings.allowedChannels = parsedChannels.map((p) => p.channelId);
+      }
+    }
+    if (discord?.channels?.status) {
+      const parsed = this.parseChannelString(discord.channels.status);
+      if (!settings.statusChannelId) {
+        settings.statusChannelId = parsed.channelId;
+      }
+    }
+    if (discord?.allowlist?.users) {
+      settings.allowedUsers = [...discord.allowlist.users];
+    }
+    if (Object.keys(settings).length === 0) {
+      return null;
+    }
+    return settings;
   }
   /**
    * Import Discord settings from OpenClaw configuration
    * Returns true if successful, false if no OpenClaw Discord config found
    */
   importFromOpenClaw() {
-    const openclawDiscord = this.getOpenClawDiscordConfig();
-    if (!openclawDiscord) {
+    const extracted = this.extractOpenClawDiscordSettings();
+    if (!extracted) {
       return {
         success: false,
         imported: {},
@@ -1232,14 +1344,17 @@ var ConfigManager = class {
       };
     }
     const imported = {};
-    if (openclawDiscord.token) {
-      imported.token = openclawDiscord.token;
+    if (extracted.token) {
+      imported.token = extracted.token;
     }
-    if (openclawDiscord.allowlist?.channels && openclawDiscord.allowlist.channels.length > 0) {
-      imported.chatChannelId = openclawDiscord.allowlist.channels[0];
-      if (openclawDiscord.allowlist.channels.length > 1) {
-        imported.statusChannelId = openclawDiscord.allowlist.channels[1];
-      }
+    if (extracted.guildId) {
+      imported.guildId = extracted.guildId;
+    }
+    if (extracted.chatChannelId) {
+      imported.chatChannelId = extracted.chatChannelId;
+    }
+    if (extracted.statusChannelId) {
+      imported.statusChannelId = extracted.statusChannelId;
     }
     if (Object.keys(imported).length === 0) {
       return {
@@ -1261,6 +1376,46 @@ var ConfigManager = class {
       message: `Imported ${Object.keys(imported).length} setting(s) from OpenClaw`
     };
   }
+  /**
+   * Update guildId after bot connects and detects it
+   * This is called when the bot auto-detects the guild from connection
+   */
+  updateGuildId(guildId) {
+    const currentDiscord = this.getDiscordConfig();
+    if (!currentDiscord.guildId) {
+      this.setDiscordConfig({
+        ...currentDiscord,
+        guildId
+      });
+    }
+  }
+  /**
+   * Get summary of what can be imported from OpenClaw
+   * Useful for displaying to user before import
+   */
+  getOpenClawImportSummary() {
+    const extracted = this.extractOpenClawDiscordSettings();
+    if (!extracted) {
+      return {
+        hasConfig: false,
+        availableSettings: [],
+        extracted: null
+      };
+    }
+    const availableSettings = [];
+    if (extracted.token) availableSettings.push("Bot Token");
+    if (extracted.guildId) availableSettings.push("Server (Guild) ID");
+    if (extracted.chatChannelId) availableSettings.push("Chat Channel");
+    if (extracted.statusChannelId) availableSettings.push("Status Channel");
+    if (extracted.allowedChannels && extracted.allowedChannels.length > 0) {
+      availableSettings.push(`${extracted.allowedChannels.length} Allowed Channel(s)`);
+    }
+    return {
+      hasConfig: true,
+      availableSettings,
+      extracted
+    };
+  }
   /**
    * Get OpenClaw config file path
    */
@@ -1274,7 +1429,8 @@ import {
   Client,
   GatewayIntentBits,
   TextChannel,
-  Partials
+  Partials,
+  PermissionFlagsBits
 } from "discord.js";
 var Bot = class {
   client;
@@ -1409,6 +1565,126 @@ var Bot = class {
   get isConnected() {
     return this.client.isReady();
   }
+  /**
+   * Detect guild ID from connected guilds
+   * Returns the first guild the bot is connected to, or the configured guildId
+   */
+  async detectGuildId() {
+    if (!this.client.isReady()) {
+      return this.config.guildId || null;
+    }
+    if (this.config.guildId) {
+      const guild = this.client.guilds.cache.get(this.config.guildId);
+      if (guild) {
+        return this.config.guildId;
+      }
+    }
+    const firstGuild = this.client.guilds.cache.first();
+    return firstGuild?.id || null;
+  }
+  /**
+   * Get all connected guilds
+   */
+  getConnectedGuilds() {
+    return this.client.guilds.cache;
+  }
+  /**
+   * Get existing webhooks in a channel
+   */
+  async getExistingWebhooks(channelId) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!(channel instanceof TextChannel)) {
+      throw new Error("Channel is not a text channel");
+    }
+    const permissions = channel.permissionsFor(this.client.user);
+    if (!permissions?.has(PermissionFlagsBits.ManageWebhooks)) {
+      throw new Error("Bot does not have MANAGE_WEBHOOKS permission in this channel");
+    }
+    const webhooks = await channel.fetchWebhooks();
+    return Array.from(webhooks.values());
+  }
+  /**
+   * Check if bot has webhook management permission in a channel
+   */
+  async hasWebhookPermission(channelId) {
+    try {
+      const channel = await this.client.channels.fetch(channelId);
+      if (!(channel instanceof TextChannel)) {
+        return false;
+      }
+      const permissions = channel.permissionsFor(this.client.user);
+      return permissions?.has(PermissionFlagsBits.ManageWebhooks) ?? false;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Auto-create webhooks for agents in a channel
+   * @param channelId - The channel to create webhooks in
+   * @param agents - Array of agent definitions to create webhooks for
+   * @param onProgress - Optional callback for progress updates
+   * @returns Record of agentId -> webhook URL
+   */
+  async autoCreateWebhooks(channelId, agents, onProgress) {
+    const channel = await this.client.channels.fetch(channelId);
+    if (!(channel instanceof TextChannel)) {
+      throw new Error("Channel is not a text channel");
+    }
+    const permissions = channel.permissionsFor(this.client.user);
+    if (!permissions?.has(PermissionFlagsBits.ManageWebhooks)) {
+      throw new Error("Bot does not have MANAGE_WEBHOOKS permission in this channel");
+    }
+    const existingWebhooks = await channel.fetchWebhooks();
+    const webhooksByName = /* @__PURE__ */ new Map();
+    for (const webhook of existingWebhooks.values()) {
+      if (webhook.name) {
+        webhooksByName.set(webhook.name, webhook);
+      }
+    }
+    const result = {};
+    let current = 0;
+    const total = agents.length;
+    for (const agent of agents) {
+      current++;
+      const webhookName = `${agent.emoji} ${agent.name}`;
+      if (onProgress) {
+        onProgress(current, total, agent.name);
+      }
+      const existing = webhooksByName.get(webhookName);
+      if (existing) {
+        result[agent.id] = existing.url;
+        continue;
+      }
+      try {
+        const webhook = await channel.createWebhook({
+          name: webhookName,
+          reason: `Too Many Claw - Auto-created webhook for agent: ${agent.id}`
+        });
+        result[agent.id] = webhook.url;
+        await new Promise((resolve) => setTimeout(resolve, 500));
+      } catch (error) {
+        console.error(`Failed to create webhook for ${agent.name}:`, error);
+      }
+    }
+    return result;
+  }
+  /**
+   * Delete a webhook by URL
+   */
+  async deleteWebhook(webhookUrl) {
+    try {
+      const match = webhookUrl.match(/webhooks\/(\d+)\/([\w-]+)/);
+      if (!match) {
+        return false;
+      }
+      const [, id, token] = match;
+      const webhook = await this.client.fetchWebhook(id, token);
+      await webhook.delete("Too Many Claw - Webhook cleanup");
+      return true;
+    } catch {
+      return false;
+    }
+  }
 };
 
 // src/discord/WebhookManager.ts
@@ -1574,6 +1850,51 @@ var DiscordAdapter = class {
   get isConnected() {
     return this.bot.isConnected;
   }
+  /**
+   * Detect guild ID from connected bot
+   */
+  async detectGuildId() {
+    return this.bot.detectGuildId();
+  }
+  /**
+   * Get all connected guilds
+   */
+  getConnectedGuilds() {
+    return this.bot.getConnectedGuilds();
+  }
+  /**
+   * Check if bot has webhook permission in channel
+   */
+  async hasWebhookPermission(channelId) {
+    return this.bot.hasWebhookPermission(channelId);
+  }
+  /**
+   * Get existing webhooks in a channel
+   */
+  async getExistingWebhooks(channelId) {
+    return this.bot.getExistingWebhooks(channelId);
+  }
+  /**
+   * Auto-create webhooks for all agents
+   * @param channelId - Channel to create webhooks in
+   * @param onProgress - Progress callback
+   * @returns Record of agentId -> webhook URL
+   */
+  async autoCreateWebhooks(channelId, onProgress) {
+    return this.bot.autoCreateWebhooks(channelId, AGENT_DEFINITIONS, onProgress);
+  }
+  /**
+   * Auto-create webhooks for specific agents
+   */
+  async autoCreateWebhooksForAgents(channelId, agents, onProgress) {
+    return this.bot.autoCreateWebhooks(channelId, agents, onProgress);
+  }
+  /**
+   * Delete a webhook
+   */
+  async deleteWebhook(webhookUrl) {
+    return this.bot.deleteWebhook(webhookUrl);
+  }
 };
 
 // src/cli.ts
@@ -1641,16 +1962,26 @@ async function checkAndImportOpenClaw(config) {
   console.log(chalk3.green("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518"));
   const openclawDiscord = config.getOpenClawDiscordConfig();
   if (!openclawDiscord) return false;
+  const summary = config.getOpenClawImportSummary();
+  const extracted = summary.extracted;
   console.log(chalk3.white("\nThe following settings can be imported:\n"));
-  if (openclawDiscord.token) {
-    const maskedToken = openclawDiscord.token.substring(0, 10) + "..." + openclawDiscord.token.slice(-4);
+  if (extracted?.token) {
+    const maskedToken = extracted.token.substring(0, 10) + "..." + extracted.token.slice(-4);
     console.log(chalk3.gray(`  \u2022 Bot Token: ${maskedToken}`));
   }
-  if (openclawDiscord.allowlist?.channels && openclawDiscord.allowlist.channels.length > 0) {
-    console.log(chalk3.gray(`  \u2022 Allowed Channels: ${openclawDiscord.allowlist.channels.length} channel(s)`));
-    openclawDiscord.allowlist.channels.forEach((ch, i) => {
-      const label = i === 0 ? "(will use as chat channel)" : i === 1 ? "(will use as status channel)" : "";
-      console.log(chalk3.gray(`      - ${ch} ${label}`));
+  if (extracted?.guildId) {
+    console.log(chalk3.gray(`  \u2022 Server (Guild) ID: ${extracted.guildId}`));
+  }
+  if (extracted?.chatChannelId) {
+    console.log(chalk3.gray(`  \u2022 Chat Channel: ${extracted.chatChannelId}`));
+  }
+  if (extracted?.statusChannelId) {
+    console.log(chalk3.gray(`  \u2022 Status Channel: ${extracted.statusChannelId}`));
+  }
+  if (extracted?.allowedChannels && extracted.allowedChannels.length > 0) {
+    console.log(chalk3.gray(`  \u2022 All Allowed Channels: ${extracted.allowedChannels.length} channel(s)`));
+    extracted.allowedChannels.forEach((ch) => {
+      console.log(chalk3.gray(`      - ${ch}`));
     });
   }
   console.log();
@@ -1673,6 +2004,9 @@ async function checkAndImportOpenClaw(config) {
     if (result.imported.token) {
       console.log(chalk3.green("  \u2713 Bot Token"));
     }
+    if (result.imported.guildId) {
+      console.log(chalk3.green(`  \u2713 Server (Guild) ID: ${result.imported.guildId}`));
+    }
     if (result.imported.chatChannelId) {
       console.log(chalk3.green(`  \u2713 Chat Channel: ${result.imported.chatChannelId}`));
     }
@@ -1838,26 +2172,40 @@ async function runDiscordSetup(config) {
   console.log(chalk3.green("\n\u2713 Discord settings saved successfully!"));
 }
 async function runWebhookSetup(config) {
-  console.log(chalk3.gray("\nTo create a webhook:"));
-  console.log(chalk3.gray("  1. Go to your Discord channel settings"));
-  console.log(chalk3.gray('  2. Click "Integrations" \u2192 "Webhooks"'));
-  console.log(chalk3.gray("  3. Create a new webhook and copy its URL\n"));
+  const discordConfig = config.getDiscordConfig();
+  const hasDiscordConfig = !!(discordConfig.token && discordConfig.chatChannelId);
+  const choices = [
+    ...hasDiscordConfig ? [{ name: "\u{1F916} Auto-create webhooks (requires bot connection)", value: "auto" }] : [],
+    { name: "\u{1F4DD} Use a single webhook for all agents", value: "single" },
+    { name: "\u{1F4C1} Configure webhooks per category", value: "category" },
+    { name: "\u{1F527} Configure webhooks per agent", value: "individual" },
+    { name: "\u23ED\uFE0F  Skip webhook configuration", value: "skip" }
+  ];
+  if (!hasDiscordConfig) {
+    console.log(chalk3.yellow("\n\u26A0 Auto-create webhooks requires Discord to be configured first."));
+    console.log(chalk3.gray("  Run Discord setup to enable this feature.\n"));
+  }
+  console.log(chalk3.gray("\nWebhooks allow each agent to have a unique name and avatar in Discord."));
+  console.log(chalk3.gray("You can create them automatically or manually.\n"));
   const { webhookMode } = await inquirer.prompt([
     {
       type: "list",
       name: "webhookMode",
       message: "How would you like to configure webhooks?",
-      choices: [
-        { name: "Use a single webhook for all agents", value: "single" },
-        { name: "Configure webhooks per category", value: "category" },
-        { name: "Configure webhooks per agent", value: "individual" },
-        { name: "Skip webhook configuration", value: "skip" }
-      ]
+      choices
     }
   ]);
   if (webhookMode === "skip") {
     return;
   }
+  if (webhookMode === "auto") {
+    await runAutoWebhookSetup(config);
+    return;
+  }
+  console.log(chalk3.gray("\nTo create a webhook manually:"));
+  console.log(chalk3.gray("  1. Go to your Discord channel settings"));
+  console.log(chalk3.gray('  2. Click "Integrations" \u2192 "Webhooks"'));
+  console.log(chalk3.gray("  3. Create a new webhook and copy its URL\n"));
   if (webhookMode === "single") {
     const { webhookUrl } = await inquirer.prompt([
       {
@@ -1931,6 +2279,114 @@ async function runWebhookSetup(config) {
     }
   }
 }
+async function runAutoWebhookSetup(config) {
+  console.log(chalk3.cyan("\n\u{1F916} Auto-Create Webhooks\n"));
+  console.log(chalk3.gray("This will connect to Discord and automatically create webhooks for all 35 agents."));
+  console.log(chalk3.gray("The bot needs MANAGE_WEBHOOKS permission in the target channel.\n"));
+  const discordConfig = config.getDiscordConfig();
+  if (!discordConfig.token) {
+    console.log(chalk3.red("\u274C Discord bot token not configured."));
+    console.log(chalk3.gray("Run `tmc setup` to configure Discord settings first.\n"));
+    return;
+  }
+  if (!discordConfig.chatChannelId) {
+    console.log(chalk3.red("\u274C Chat channel not configured."));
+    console.log(chalk3.gray("Run `tmc setup` to configure Discord settings first.\n"));
+    return;
+  }
+  console.log(chalk3.yellow("\u26A0 Important: Discord limits webhooks to 15 per channel."));
+  console.log(chalk3.gray(`  You have ${AGENT_DEFINITIONS.length} agents, so some will share webhooks or fail to create.`));
+  console.log(chalk3.gray("  Consider using multiple channels or a single shared webhook if this is an issue.\n"));
+  const { confirm } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "confirm",
+      message: `Create webhooks for all ${AGENT_DEFINITIONS.length} agents in channel ${discordConfig.chatChannelId}?`,
+      default: true
+    }
+  ]);
+  if (!confirm) {
+    console.log(chalk3.yellow("\nWebhook creation cancelled.\n"));
+    return;
+  }
+  const connectSpinner = ora("Connecting to Discord...").start();
+  let adapter;
+  try {
+    adapter = new DiscordAdapter({
+      token: discordConfig.token,
+      guildId: discordConfig.guildId || "0",
+      // Placeholder, will be auto-detected
+      chatChannelId: discordConfig.chatChannelId,
+      statusChannelId: discordConfig.statusChannelId
+    });
+    await adapter.connect();
+    connectSpinner.succeed("Connected to Discord");
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  } catch (error) {
+    connectSpinner.fail("Failed to connect to Discord");
+    console.log(chalk3.red(`
+Error: ${error instanceof Error ? error.message : "Unknown error"}`));
+    console.log(chalk3.gray("\nMake sure your bot token is valid and the bot is invited to your server.\n"));
+    return;
+  }
+  try {
+    if (!discordConfig.guildId) {
+      const detectSpinner = ora("Detecting server (guild) ID...").start();
+      const detectedGuildId = await adapter.detectGuildId();
+      if (detectedGuildId) {
+        config.updateGuildId(detectedGuildId);
+        detectSpinner.succeed(`Detected server ID: ${detectedGuildId}`);
+      } else {
+        detectSpinner.warn("Could not auto-detect server ID (bot may not be in any servers)");
+      }
+    }
+    const permSpinner = ora("Checking webhook permissions...").start();
+    const hasPermission = await adapter.hasWebhookPermission(discordConfig.chatChannelId);
+    if (!hasPermission) {
+      permSpinner.fail("Bot lacks MANAGE_WEBHOOKS permission");
+      console.log(chalk3.red("\n\u274C The bot does not have permission to manage webhooks in this channel."));
+      console.log(chalk3.gray("\nTo fix this:"));
+      console.log(chalk3.gray("  1. Go to your Discord server settings"));
+      console.log(chalk3.gray("  2. Navigate to Roles or Channel Permissions"));
+      console.log(chalk3.gray('  3. Grant the bot "Manage Webhooks" permission'));
+      console.log(chalk3.gray("  4. Try again\n"));
+      await adapter.disconnect();
+      return;
+    }
+    permSpinner.succeed("Bot has webhook permissions");
+    console.log(chalk3.cyan(`
+Creating webhooks for ${AGENT_DEFINITIONS.length} agents...
+`));
+    const progressSpinner = ora("Starting webhook creation...").start();
+    const webhooks = await adapter.autoCreateWebhooks(
+      discordConfig.chatChannelId,
+      (current, total, agentName) => {
+        progressSpinner.text = `Creating webhooks... (${current}/${total}) ${agentName}`;
+      }
+    );
+    progressSpinner.succeed(`Created webhooks for ${Object.keys(webhooks).length} agents`);
+    const saveSpinner = ora("Saving webhook configuration...").start();
+    const existingWebhooks = config.getAllWebhooks();
+    config.setAllWebhooks({ ...existingWebhooks, ...webhooks });
+    saveSpinner.succeed("Webhook configuration saved");
+    console.log(chalk3.green(`
+\u2705 Successfully configured ${Object.keys(webhooks).length} webhooks!
+`));
+    const missingCount = AGENT_DEFINITIONS.length - Object.keys(webhooks).length;
+    if (missingCount > 0) {
+      console.log(chalk3.yellow(`\u26A0 ${missingCount} webhook(s) could not be created.`));
+      console.log(chalk3.gray("  Possible reasons:"));
+      console.log(chalk3.gray("  \u2022 Discord's 15 webhook per channel limit reached"));
+      console.log(chalk3.gray("  \u2022 Rate limiting from Discord API"));
+      console.log(chalk3.gray("  \u2022 Webhook already exists with the same name"));
+      console.log(chalk3.gray("\n  Consider using multiple channels or a shared webhook for remaining agents.\n"));
+    }
+  } finally {
+    const disconnectSpinner = ora("Disconnecting from Discord...").start();
+    await adapter.disconnect();
+    disconnectSpinner.succeed("Disconnected from Discord");
+  }
+}
 function viewConfiguration(config) {
   console.log(chalk3.cyan("\n\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
   console.log(chalk3.cyan("\u2502        \u{1F4CA} Current Configuration             \u2502"));
@@ -2081,6 +2537,94 @@ program.command("uninstall").description("Remove Too Many Claw configuration").a
     console.error(chalk3.red(error));
   }
 });
+program.command("debug").description("Debug OpenClaw configuration detection").option("--raw", "Show raw config (WARNING: may expose sensitive data)").action((options) => {
+  console.log(chalk3.cyan("\n\u{1F50D} Too Many Claw - Debug Information\n"));
+  const config = new ConfigManager();
+  console.log(chalk3.yellow("\u2501\u2501\u2501 OpenClaw Configuration \u2501\u2501\u2501\n"));
+  const openclawPath = config.getOpenClawConfigPath();
+  console.log(chalk3.white("Config file path:"));
+  console.log(chalk3.gray(`  ${openclawPath}`));
+  console.log(chalk3.white("File exists:"), config.hasOpenClawConfig() ? chalk3.green("Yes") : chalk3.red("No"));
+  if (config.hasOpenClawConfig()) {
+    const rawConfig = config.getOpenClawRawConfig();
+    if (rawConfig) {
+      console.log(chalk3.white("\nTop-level keys:"));
+      const topKeys = Object.keys(rawConfig);
+      topKeys.forEach((key) => {
+        const value = rawConfig[key];
+        const valueType = Array.isArray(value) ? "array" : typeof value;
+        const subKeys = valueType === "object" && value ? Object.keys(value) : [];
+        console.log(chalk3.gray(`  \u2022 ${key} (${valueType})${subKeys.length > 0 ? ": " + subKeys.join(", ") : ""}`));
+      });
+      console.log(chalk3.white("\nDiscord config paths checked:"));
+      const paths = [
+        { path: "gateway.discord", value: rawConfig?.gateway?.discord },
+        { path: "channels.discord", value: rawConfig?.channels?.discord },
+        { path: "discord", value: rawConfig?.discord },
+        { path: "providers.discord", value: rawConfig?.providers?.discord }
+      ];
+      paths.forEach(({ path: path2, value }) => {
+        if (value) {
+          const keys = typeof value === "object" ? Object.keys(value) : [];
+          console.log(chalk3.green(`  \u2713 ${path2}`) + chalk3.gray(` (keys: ${keys.join(", ") || "none"})`));
+        } else {
+          console.log(chalk3.gray(`  \u25CB ${path2} - not found`));
+        }
+      });
+      if (options.raw) {
+        console.log(chalk3.yellow("\n\u26A0 Raw OpenClaw config (may contain sensitive data):"));
+        console.log(chalk3.gray(JSON.stringify(rawConfig, null, 2)));
+      }
+    }
+  }
+  console.log(chalk3.yellow("\n\u2501\u2501\u2501 TMC OpenClaw Detection \u2501\u2501\u2501\n"));
+  console.log(chalk3.white("hasOpenClawConfig():"), config.hasOpenClawConfig() ? chalk3.green("true") : chalk3.red("false"));
+  console.log(chalk3.white("hasOpenClawDiscordConfig():"), config.hasOpenClawDiscordConfig() ? chalk3.green("true") : chalk3.red("false"));
+  const extracted = config.extractOpenClawDiscordSettings();
+  if (extracted) {
+    console.log(chalk3.white("\nExtracted Discord settings:"));
+    if (extracted.token) {
+      const masked = extracted.token.substring(0, 10) + "..." + extracted.token.slice(-4);
+      console.log(chalk3.green(`  \u2713 token: ${masked}`));
+    } else {
+      console.log(chalk3.gray("  \u25CB token: not found"));
+    }
+    console.log(extracted.guildId ? chalk3.green(`  \u2713 guildId: ${extracted.guildId}`) : chalk3.gray("  \u25CB guildId: not found"));
+    console.log(extracted.chatChannelId ? chalk3.green(`  \u2713 chatChannelId: ${extracted.chatChannelId}`) : chalk3.gray("  \u25CB chatChannelId: not found"));
+    console.log(extracted.statusChannelId ? chalk3.green(`  \u2713 statusChannelId: ${extracted.statusChannelId}`) : chalk3.gray("  \u25CB statusChannelId: not found"));
+    if (extracted.allowedChannels && extracted.allowedChannels.length > 0) {
+      console.log(chalk3.green(`  \u2713 allowedChannels: ${extracted.allowedChannels.join(", ")}`));
+    }
+  } else {
+    console.log(chalk3.gray("\nNo Discord settings could be extracted from OpenClaw config."));
+  }
+  console.log(chalk3.yellow("\n\u2501\u2501\u2501 Current TMC Configuration \u2501\u2501\u2501\n"));
+  const tmcConfig = config.getDiscordConfig();
+  const webhooks = config.getAllWebhooks();
+  console.log(chalk3.white("Discord settings:"));
+  if (tmcConfig.token) {
+    const masked = tmcConfig.token.substring(0, 10) + "..." + tmcConfig.token.slice(-4);
+    console.log(chalk3.gray(`  \u2022 token: ${masked}`));
+  } else {
+    console.log(chalk3.gray("  \u2022 token: not set"));
+  }
+  console.log(chalk3.gray(`  \u2022 guildId: ${tmcConfig.guildId || "not set"}`));
+  console.log(chalk3.gray(`  \u2022 chatChannelId: ${tmcConfig.chatChannelId || "not set"}`));
+  console.log(chalk3.gray(`  \u2022 statusChannelId: ${tmcConfig.statusChannelId || "not set"}`));
+  console.log(chalk3.white("\nWebhooks configured:"), Object.keys(webhooks).length);
+  console.log(chalk3.white("Discord fully configured:"), config.isDiscordConfigured() ? chalk3.green("Yes") : chalk3.yellow("No"));
+  console.log(chalk3.cyan("\n\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\n"));
+  if (!config.hasOpenClawConfig()) {
+    console.log(chalk3.yellow("\u{1F4A1} Tip: OpenClaw config not found. Make sure OpenClaw is installed and run `openclaw onboard` first.\n"));
+  } else if (!config.hasOpenClawDiscordConfig()) {
+    console.log(chalk3.yellow("\u{1F4A1} Tip: OpenClaw config exists but no Discord token found."));
+    console.log(chalk3.gray("   The config structure may be different than expected."));
+    console.log(chalk3.gray("   Please share the output above (without --raw) to help diagnose.\n"));
+  } else if (!extracted?.token) {
+    console.log(chalk3.yellow("\u{1F4A1} Tip: Discord config detected but token not extracted."));
+    console.log(chalk3.gray("   Check the paths above to see where Discord settings are stored.\n"));
+  }
+});
 program.command("agents").description("List all available agents").option("-c, --category <category>", "Filter by category").action((options) => {
   console.log(chalk3.cyan("\n\u{1F980} Too Many Claw - Agent Directory\n"));
   let agents = AGENT_DEFINITIONS;