@nextclaw/channel-runtime 0.1.16 → 0.1.17

package/dist/index.d.ts

@@ -56,15 +56,23 @@ declare class DingTalkChannel extends BaseChannel<Config["channels"]["dingtalk"]
 }
 
 declare class DiscordChannel extends BaseChannel<Config["channels"]["discord"]> {
+    private sessionManager?;
+    private coreConfig?;
     name: string;
     private client;
     private readonly typingController;
-    constructor(config: Config["channels"]["discord"], bus: MessageBus);
+    private readonly commandRegistry;
+    constructor(config: Config["channels"]["discord"], bus: MessageBus, sessionManager?: SessionManager | undefined, coreConfig?: Config | undefined);
     start(): Promise<void>;
     stop(): Promise<void>;
     handleControlMessage(msg: OutboundMessage): Promise<boolean>;
     send(msg: OutboundMessage): Promise<void>;
     private handleIncoming;
+    private handleInteraction;
+    private handleSlashCommand;
+    private replyInteraction;
+    private registerSlashCommands;
+    private buildSlashCommandPayloads;
     private resolveProxyAgent;
     private resolveAccountId;
     private isAllowedByPolicy;

package/dist/index.js

@@ -176,7 +176,10 @@ import {
   Client,
   GatewayIntentBits,
   Partials,
-  MessageFlags
+  MessageFlags,
+  REST,
+  Routes,
+  ApplicationCommandOptionType
 } from "discord.js";
 import { ProxyAgent, fetch as fetch2 } from "undici";
 import { join } from "path";
@@ -227,7 +230,7 @@ var ChannelTypingController = class {
 };
 
 // src/channels/discord.ts
-import { isTypingStopControlMessage } from "@nextclaw/core";
+import { CommandRegistry, isTypingStopControlMessage } from "@nextclaw/core";
 var DEFAULT_MEDIA_MAX_MB = 8;
 var MEDIA_FETCH_TIMEOUT_MS = 15e3;
 var TYPING_HEARTBEAT_MS = 6e3;
@@ -237,12 +240,13 @@ var DISCORD_MAX_LINES_PER_MESSAGE = 17;
 var STREAM_EDIT_MIN_INTERVAL_MS = 600;
 var STREAM_MAX_UPDATES_PER_MESSAGE = 40;
 var FENCE_RE = /^( {0,3})(`{3,}|~{3,})(.*)$/;
+var SLASH_GUILD_THRESHOLD = 10;
 var DiscordChannel = class extends BaseChannel {
-  name = "discord";
-  client = null;
-  typingController;
-  constructor(config, bus) {
+  constructor(config, bus, sessionManager, coreConfig) {
     super(config, bus);
+    this.sessionManager = sessionManager;
+    this.coreConfig = coreConfig;
+    this.commandRegistry = this.coreConfig ? new CommandRegistry(this.coreConfig, this.sessionManager) : null;
     this.typingController = new ChannelTypingController({
       heartbeatMs: TYPING_HEARTBEAT_MS,
       autoStopMs: TYPING_AUTO_STOP_MS,
@@ -259,6 +263,10 @@ var DiscordChannel = class extends BaseChannel {
       }
     });
   }
+  name = "discord";
+  client = null;
+  typingController;
+  commandRegistry;
   async start() {
     if (!this.config.token) {
       throw new Error("Discord token not configured");
@@ -270,10 +278,14 @@ var DiscordChannel = class extends BaseChannel {
     });
     this.client.on("ready", () => {
       console.log("Discord bot connected");
+      void this.registerSlashCommands();
     });
     this.client.on("messageCreate", async (message) => {
       await this.handleIncoming(message);
     });
+    this.client.on("interactionCreate", async (interaction) => {
+      await this.handleInteraction(interaction);
+    });
     await this.client.login(this.config.token);
   }
   async stop() {
@@ -409,6 +421,97 @@ var DiscordChannel = class extends BaseChannel {
       throw error;
     }
   }
+  async handleInteraction(interaction) {
+    if (!interaction.isChatInputCommand()) {
+      return;
+    }
+    await this.handleSlashCommand(interaction);
+  }
+  async handleSlashCommand(interaction) {
+    if (!this.commandRegistry) {
+      await this.replyInteraction(interaction, "Slash commands are not available.", true);
+      return;
+    }
+    const channelId = interaction.channelId;
+    if (!channelId) {
+      await this.replyInteraction(interaction, "Slash commands are not available in this channel.", true);
+      return;
+    }
+    const senderId = interaction.user.id;
+    const isGroup = Boolean(interaction.guildId);
+    if (!this.isAllowedByPolicy({ senderId, channelId, isGroup })) {
+      await this.replyInteraction(interaction, "You are not authorized to use commands here.", true);
+      return;
+    }
+    const args = {};
+    for (const option of interaction.options.data) {
+      if (typeof option.name === "string" && option.value !== void 0) {
+        args[option.name] = option.value;
+      }
+    }
+    try {
+      const result = await this.commandRegistry.execute(interaction.commandName, args, {
+        channel: this.name,
+        chatId: channelId,
+        senderId,
+        sessionKey: `${this.name}:${channelId}`
+      });
+      await this.replyInteraction(interaction, result.content, result.ephemeral ?? true);
+    } catch (error) {
+      await this.replyInteraction(interaction, "Command failed to execute.", true);
+      console.error(`Discord slash command error: ${String(error)}`);
+    }
+  }
+  async replyInteraction(interaction, content, ephemeral) {
+    const payload = { content, ephemeral };
+    if (interaction.deferred || interaction.replied) {
+      await interaction.followUp(payload);
+      return;
+    }
+    await interaction.reply(payload);
+  }
+  async registerSlashCommands() {
+    if (!this.client || !this.commandRegistry) {
+      return;
+    }
+    const appId = this.client.application?.id ?? this.client.user?.id;
+    if (!appId) {
+      return;
+    }
+    const commands = this.buildSlashCommandPayloads();
+    if (!commands.length) {
+      return;
+    }
+    const rest = new REST({ version: "10" }).setToken(this.config.token);
+    let guildIds = [];
+    try {
+      const guilds = await this.client.guilds.fetch();
+      guildIds = [...guilds.keys()];
+    } catch (error) {
+      console.error(`Failed to fetch Discord guild list: ${String(error)}`);
+    }
+    try {
+      if (guildIds.length > 0 && guildIds.length <= SLASH_GUILD_THRESHOLD) {
+        for (const guildId of guildIds) {
+          await rest.put(Routes.applicationGuildCommands(appId, guildId), { body: commands });
+        }
+        console.log(`Discord slash commands registered for ${guildIds.length} guild(s).`);
+      } else {
+        await rest.put(Routes.applicationCommands(appId), { body: commands });
+        console.log("Discord slash commands registered globally.");
+      }
+    } catch (error) {
+      console.error(`Failed to register Discord slash commands: ${String(error)}`);
+    }
+  }
+  buildSlashCommandPayloads() {
+    const specs = this.commandRegistry?.listSlashCommands() ?? [];
+    return specs.map((spec) => ({
+      name: spec.name,
+      description: spec.description,
+      options: mapCommandOptions(spec.options)
+    }));
+  }
   resolveProxyAgent() {
     const proxy = this.config.proxy?.trim();
     if (!proxy) {
@@ -610,6 +713,28 @@ var DiscordChannel = class extends BaseChannel {
     this.typingController.stop(channelId);
   }
 };
+function mapCommandOptions(options) {
+  if (!options || options.length === 0) {
+    return void 0;
+  }
+  return options.map((option) => ({
+    name: option.name,
+    description: option.description,
+    type: mapCommandOptionType(option.type),
+    required: option.required ?? false
+  }));
+}
+function mapCommandOptionType(type) {
+  switch (type) {
+    case "boolean":
+      return ApplicationCommandOptionType.Boolean;
+    case "number":
+      return ApplicationCommandOptionType.Number;
+    case "string":
+    default:
+      return ApplicationCommandOptionType.String;
+  }
+}
 function sanitizeAttachmentName(name) {
   return name.replace(/[\\/:*?"<>|]/g, "_");
 }
@@ -3453,7 +3578,7 @@ var BUILTIN_CHANNEL_RUNTIMES = {
   discord: {
     id: "discord",
     isEnabled: (config) => config.channels.discord.enabled,
-    createChannel: (context) => new DiscordChannel(context.config.channels.discord, context.bus)
+    createChannel: (context) => new DiscordChannel(context.config.channels.discord, context.bus, context.sessionManager, context.config)
   },
   feishu: {
     id: "feishu",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-runtime",
-  "version": "0.1.16",
+  "version": "0.1.17",
   "private": false,
   "description": "Runtime implementations for NextClaw builtin channel plugins.",
   "type": "module",
@@ -15,7 +15,7 @@
   ],
   "dependencies": {
     "@larksuiteoapi/node-sdk": "^1.58.0",
-    "@nextclaw/core": "^0.6.31",
+    "@nextclaw/core": "^0.6.32",
     "@slack/socket-mode": "^1.3.3",
     "@slack/web-api": "^7.6.0",
     "dingtalk-stream": "^2.1.4",