too-many-claw 1.0.3 → 1.0.5

package/dist/cli.js

@@ -1073,10 +1073,12 @@ var DEFAULT_CONFIG = {
 };
 var ConfigManager = class {
   configPath;
+  openclawConfigPath;
   config;
   constructor() {
     const openclawDir = path.join(os.homedir(), ".openclaw");
     this.configPath = path.join(openclawDir, "too-many-claw.json");
+    this.openclawConfigPath = path.join(openclawDir, "openclaw.json");
     this.config = this.load();
   }
   /**
@@ -1180,6 +1182,172 @@ var ConfigManager = class {
     } catch {
     }
   }
+  // ============================================
+  // OpenClaw Integration
+  // ============================================
+  /**
+   * Check if OpenClaw config file exists
+   */
+  hasOpenClawConfig() {
+    return fs.existsSync(this.openclawConfigPath);
+  }
+  /**
+   * Read OpenClaw configuration file
+   */
+  readOpenClawConfig() {
+    try {
+      if (!this.hasOpenClawConfig()) {
+        return null;
+      }
+      return fs.readJsonSync(this.openclawConfigPath);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Check if OpenClaw has Discord configuration
+   */
+  hasOpenClawDiscordConfig() {
+    const config = this.readOpenClawConfig();
+    return !!config?.gateway?.discord?.token;
+  }
+  /**
+   * Get raw Discord settings from OpenClaw config
+   */
+  getOpenClawDiscordConfig() {
+    const config = this.readOpenClawConfig();
+    return config?.gateway?.discord ?? config?.discord ?? null;
+  }
+  /**
+   * Extract and normalize Discord settings from OpenClaw config
+   * Returns a clean, normalized structure regardless of how OpenClaw stores it
+   */
+  extractOpenClawDiscordSettings() {
+    const discord = this.getOpenClawDiscordConfig();
+    if (!discord) 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 (discord.channels?.chat) {
+      settings.chatChannelId = discord.channels.chat;
+    } else if (discord.channels?.default) {
+      settings.chatChannelId = discord.channels.default;
+    } else if (discord.allowlist?.channels && discord.allowlist.channels.length > 0) {
+      settings.chatChannelId = discord.allowlist.channels[0];
+    }
+    if (discord.channels?.status) {
+      settings.statusChannelId = discord.channels.status;
+    } else if (discord.allowlist?.channels && discord.allowlist.channels.length > 1) {
+      settings.statusChannelId = discord.allowlist.channels[1];
+    }
+    if (discord.allowlist?.channels) {
+      settings.allowedChannels = [...discord.allowlist.channels];
+    }
+    if (discord.allowlist?.users) {
+      settings.allowedUsers = [...discord.allowlist.users];
+    }
+    return settings;
+  }
+  /**
+   * Import Discord settings from OpenClaw configuration
+   * Returns true if successful, false if no OpenClaw Discord config found
+   */
+  importFromOpenClaw() {
+    const extracted = this.extractOpenClawDiscordSettings();
+    if (!extracted) {
+      return {
+        success: false,
+        imported: {},
+        message: "No OpenClaw Discord configuration found"
+      };
+    }
+    const imported = {};
+    if (extracted.token) {
+      imported.token = extracted.token;
+    }
+    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 {
+        success: false,
+        imported: {},
+        message: "OpenClaw Discord config exists but has no usable settings"
+      };
+    }
+    const currentDiscord = this.getDiscordConfig();
+    this.setDiscordConfig({
+      ...currentDiscord,
+      // Base: existing settings
+      ...imported
+      // Override with imported values
+    });
+    return {
+      success: true,
+      imported,
+      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
+   */
+  getOpenClawConfigPath() {
+    return this.openclawConfigPath;
+  }
 };
 
 // src/discord/Bot.ts
@@ -1187,7 +1355,8 @@ import {
   Client,
   GatewayIntentBits,
   TextChannel,
-  Partials
+  Partials,
+  PermissionFlagsBits
 } from "discord.js";
 var Bot = class {
   client;
@@ -1322,6 +1491,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
@@ -1487,11 +1776,56 @@ 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
 var program = new Command();
-program.name("tmc").description("Too Many Claw - 35 AI agents collaborating via Discord").version("1.0.2");
+program.name("tmc").description("Too Many Claw - 35 AI agents collaborating via Discord").version("1.0.4");
 program.command("setup").description("Interactive setup wizard for Too Many Claw").action(async () => {
   console.log(chalk3.cyan(`
 \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
@@ -1503,20 +1837,22 @@ program.command("setup").description("Interactive setup wizard for Too Many Claw
 \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 `));
   const config = new ConfigManager();
-  const currentDiscord = config.getDiscordConfig();
+  await checkAndImportOpenClaw(config);
+  const menuChoices = [
+    { name: "\u{1F527} Full Setup (Recommended for first time)", value: "full" },
+    { name: "\u{1F916} Discord Bot Settings", value: "discord" },
+    { name: "\u{1F517} Webhook Configuration", value: "webhooks" },
+    ...config.hasOpenClawConfig() ? [{ name: "\u{1F4E5} Import from OpenClaw", value: "openclaw" }] : [],
+    { name: "\u{1F4CA} View Current Configuration", value: "view" },
+    { name: "\u{1F5D1}\uFE0F  Reset Configuration", value: "reset" },
+    { name: "\u274C Exit", value: "exit" }
+  ];
   const { setupType } = await inquirer.prompt([
     {
       type: "list",
       name: "setupType",
       message: "What would you like to configure?",
-      choices: [
-        { name: "\u{1F527} Full Setup (Recommended for first time)", value: "full" },
-        { name: "\u{1F916} Discord Bot Settings", value: "discord" },
-        { name: "\u{1F517} Webhook Configuration", value: "webhooks" },
-        { name: "\u{1F4CA} View Current Configuration", value: "view" },
-        { name: "\u{1F5D1}\uFE0F  Reset Configuration", value: "reset" },
-        { name: "\u274C Exit", value: "exit" }
-      ]
+      choices: menuChoices
     }
   ]);
   switch (setupType) {
@@ -1529,6 +1865,9 @@ program.command("setup").description("Interactive setup wizard for Too Many Claw
     case "webhooks":
       await runWebhookSetup(config);
       break;
+    case "openclaw":
+      await importFromOpenClawManual(config);
+      break;
     case "view":
       viewConfiguration(config);
       break;
@@ -1540,16 +1879,134 @@ program.command("setup").description("Interactive setup wizard for Too Many Claw
       break;
   }
 });
+async function checkAndImportOpenClaw(config) {
+  if (!config.hasOpenClawDiscordConfig()) {
+    return false;
+  }
+  console.log(chalk3.green("\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\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510"));
+  console.log(chalk3.green("\u2502  \u2728 OpenClaw Discord configuration detected!                \u2502"));
+  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 (extracted?.token) {
+    const maskedToken = extracted.token.substring(0, 10) + "..." + extracted.token.slice(-4);
+    console.log(chalk3.gray(`  \u2022 Bot Token: ${maskedToken}`));
+  }
+  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();
+  const { shouldImport } = await inquirer.prompt([
+    {
+      type: "confirm",
+      name: "shouldImport",
+      message: "Would you like to import these settings from OpenClaw?",
+      default: true
+    }
+  ]);
+  if (!shouldImport) {
+    console.log(chalk3.gray("\nSkipped OpenClaw import.\n"));
+    return false;
+  }
+  const result = config.importFromOpenClaw();
+  if (result.success) {
+    console.log(chalk3.green("\n\u2713 Import successful!\n"));
+    console.log(chalk3.white("Imported settings:"));
+    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}`));
+    }
+    if (result.imported.statusChannelId) {
+      console.log(chalk3.green(`  \u2713 Status Channel: ${result.imported.statusChannelId}`));
+    }
+    console.log();
+    const currentConfig = config.getDiscordConfig();
+    const missing = [];
+    if (!currentConfig.guildId) missing.push("Server (Guild) ID");
+    if (!currentConfig.chatChannelId) missing.push("Chat Channel ID");
+    if (missing.length > 0) {
+      console.log(chalk3.yellow("\u26A0 The following settings still need to be configured:"));
+      missing.forEach((m) => console.log(chalk3.yellow(`  \u2022 ${m}`)));
+      console.log();
+    }
+  } else {
+    console.log(chalk3.yellow(`
+\u26A0 ${result.message}
+`));
+  }
+  return result.success;
+}
+async function importFromOpenClawManual(config) {
+  console.log(chalk3.cyan("\n\u{1F4E5} Import from OpenClaw\n"));
+  if (!config.hasOpenClawConfig()) {
+    console.log(chalk3.yellow("OpenClaw configuration file not found."));
+    console.log(chalk3.gray(`Expected location: ${config.getOpenClawConfigPath()}`));
+    console.log(chalk3.gray("\nMake sure OpenClaw is installed and configured.\n"));
+    return;
+  }
+  if (!config.hasOpenClawDiscordConfig()) {
+    console.log(chalk3.yellow("OpenClaw is installed but has no Discord configuration."));
+    console.log(chalk3.gray("\nPlease configure Discord in OpenClaw first, then try again.\n"));
+    return;
+  }
+  await checkAndImportOpenClaw(config);
+}
 async function runFullSetup(config) {
-  console.log(chalk3.cyan("\n\u{1F4CB} Step 1/3: Discord Bot Configuration\n"));
-  console.log(chalk3.gray("To use Too Many Claw, you need a Discord bot. Here's how to get one:"));
-  console.log(chalk3.gray("  1. Go to https://discord.com/developers/applications"));
-  console.log(chalk3.gray("  2. Create a new application"));
-  console.log(chalk3.gray('  3. Go to the "Bot" tab and create a bot'));
-  console.log(chalk3.gray("  4. Copy the bot token"));
-  console.log(chalk3.gray('  5. Enable "Message Content Intent" in the Bot settings'));
-  console.log(chalk3.gray("  6. Invite the bot to your server with appropriate permissions\n"));
-  await runDiscordSetup(config);
+  const currentDiscord = config.getDiscordConfig();
+  const hasToken = !!currentDiscord.token;
+  const hasGuild = !!currentDiscord.guildId;
+  const hasChatChannel = !!currentDiscord.chatChannelId;
+  if (hasToken && hasGuild && hasChatChannel) {
+    console.log(chalk3.green("\n\u2713 Discord is already configured!\n"));
+    const { reconfigure } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "reconfigure",
+        message: "Would you like to reconfigure Discord settings?",
+        default: false
+      }
+    ]);
+    if (!reconfigure) {
+      console.log(chalk3.cyan("\n\u{1F4CB} Step 1/3: Discord Bot Configuration - Skipped\n"));
+    } else {
+      console.log(chalk3.cyan("\n\u{1F4CB} Step 1/3: Discord Bot Configuration\n"));
+      await runDiscordSetup(config);
+    }
+  } else {
+    console.log(chalk3.cyan("\n\u{1F4CB} Step 1/3: Discord Bot Configuration\n"));
+    if (hasToken) {
+      console.log(chalk3.green("\u2713 Bot token already configured (imported from OpenClaw)\n"));
+    } else {
+      console.log(chalk3.gray("To use Too Many Claw, you need a Discord bot. Here's how to get one:"));
+      console.log(chalk3.gray("  1. Go to https://discord.com/developers/applications"));
+      console.log(chalk3.gray("  2. Create a new application"));
+      console.log(chalk3.gray('  3. Go to the "Bot" tab and create a bot'));
+      console.log(chalk3.gray("  4. Copy the bot token"));
+      console.log(chalk3.gray('  5. Enable "Message Content Intent" in the Bot settings'));
+      console.log(chalk3.gray("  6. Invite the bot to your server with appropriate permissions\n"));
+    }
+    await runDiscordSetup(config);
+  }
   console.log(chalk3.cyan("\n\u{1F4CB} Step 2/3: Webhook Configuration (Optional)\n"));
   console.log(chalk3.gray("Webhooks allow each agent to have a unique name and avatar."));
   console.log(chalk3.gray("Without webhooks, all agents will use the bot's identity.\n"));
@@ -1574,11 +2031,24 @@ async function runFullSetup(config) {
 }
 async function runDiscordSetup(config) {
   const currentDiscord = config.getDiscordConfig();
+  if (currentDiscord.token || currentDiscord.guildId || currentDiscord.chatChannelId) {
+    console.log(chalk3.gray("Pre-filled values (press Enter to keep, or type new value):\n"));
+    if (currentDiscord.token) {
+      console.log(chalk3.gray(`  \u2022 Token: ${currentDiscord.token.substring(0, 10)}...`));
+    }
+    if (currentDiscord.guildId) {
+      console.log(chalk3.gray(`  \u2022 Guild ID: ${currentDiscord.guildId}`));
+    }
+    if (currentDiscord.chatChannelId) {
+      console.log(chalk3.gray(`  \u2022 Chat Channel: ${currentDiscord.chatChannelId}`));
+    }
+    console.log();
+  }
   const answers = await inquirer.prompt([
     {
       type: "password",
       name: "token",
-      message: "Discord Bot Token:",
+      message: currentDiscord.token ? "Discord Bot Token (press Enter to keep current):" : "Discord Bot Token:",
       default: currentDiscord.token || "",
       mask: "*",
       validate: (input) => {
@@ -1591,7 +2061,7 @@ async function runDiscordSetup(config) {
     {
       type: "input",
       name: "guildId",
-      message: "Discord Server (Guild) ID:",
+      message: currentDiscord.guildId ? "Discord Server (Guild) ID (press Enter to keep current):" : "Discord Server (Guild) ID:",
       default: currentDiscord.guildId || "",
       validate: (input) => {
         if (!input || !/^\d{17,19}$/.test(input)) {
@@ -1603,7 +2073,7 @@ async function runDiscordSetup(config) {
     {
       type: "input",
       name: "chatChannelId",
-      message: "Chat Channel ID (main conversation channel):",
+      message: currentDiscord.chatChannelId ? "Chat Channel ID (press Enter to keep current):" : "Chat Channel ID (main conversation channel):",
       default: currentDiscord.chatChannelId || "",
       validate: (input) => {
         if (!input || !/^\d{17,19}$/.test(input)) {
@@ -1628,26 +2098,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([
       {
@@ -1721,6 +2205,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"));