clawmini 0.0.8 → 0.0.9

package/src/adapter-discord/index.test.ts

@@ -19,13 +19,28 @@ vi.mock('./state.js', () => ({
   updateDiscordState: vi.fn().mockResolvedValue(undefined),
 }));
 
+const mockRestPut = vi.fn().mockResolvedValue(true);
+
 vi.mock('discord.js', () => {
   return {
+    REST: class {
+      setToken = vi.fn().mockReturnThis();
+      put = mockRestPut;
+    },
+    Routes: {
+      applicationCommands: vi.fn().mockReturnValue('/mock/commands'),
+    },
     Client: class {
       constructor() {
         return mockClientInstance;
       }
     },
+    SlashCommandBuilder: class {
+      setName = vi.fn().mockReturnThis();
+      setDescription = vi.fn().mockReturnThis();
+      addStringOption = vi.fn().mockReturnThis();
+      toJSON = vi.fn().mockReturnValue({ name: 'mocked_command' });
+    },
     Events: {
       ClientReady: 'ready',
       MessageCreate: 'messageCreate',
@@ -79,6 +94,12 @@ describe('Discord Adapter Entry Point', () => {
       sendMessage: {
         mutate: vi.fn().mockResolvedValue({ success: true }),
       },
+      waitForMessages: {
+        subscribe: vi.fn(),
+      },
+      waitForTyping: {
+        subscribe: vi.fn(),
+      },
     } as unknown as ReturnType<typeof import('./client.js').getTRPCClient>;
     vi.mocked(getTRPCClient).mockReturnValue(mockTrpc);
     vi.mocked(readDiscordConfig).mockResolvedValue({
@@ -94,6 +115,36 @@ describe('Discord Adapter Entry Point', () => {
     vi.mocked(mockClientInstance.once).mockReturnValue(mockClientInstance);
   });
 
+  it('should register slash commands on ClientReady', async () => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let readyHandler: ((client: any) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.once).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'ready') {
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          readyHandler = cb as any;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return mockClientInstance as any;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    expect(readyHandler).toBeDefined();
+
+    if (readyHandler) {
+      await readyHandler({ user: { id: 'bot-id', tag: 'bot#1234' } });
+    }
+
+    const { slashCommands } = await import('./commands.js');
+
+    expect(mockRestPut).toHaveBeenCalledWith('/mock/commands', {
+      body: slashCommands.map((cmd) => cmd.toJSON()),
+    });
+  });
+
   it('should initialize Discord config and exit if init argument is provided', async () => {
     process.argv = ['node', 'index.js', 'init'];
     const { initDiscordConfig } = await import('./config.js');
@@ -208,6 +259,7 @@ describe('Discord Adapter Entry Point', () => {
         files: undefined,
         adapter: 'discord',
         noWait: true,
+        externalRef: 'msg-1',
       },
     });
     expect(mockTrpc.sendMessage.mutate).toHaveBeenNthCalledWith(2, {
@@ -219,6 +271,7 @@ describe('Discord Adapter Entry Point', () => {
         files: undefined,
         adapter: 'discord',
         noWait: true,
+        externalRef: 'msg-2',
       },
     });
   });
@@ -484,7 +537,12 @@ describe('Discord Adapter Entry Point', () => {
     await vi.runAllTimersAsync();
 
     expect(global.fetch).not.toHaveBeenCalled();
-    expect(replyMock).toHaveBeenCalledWith(expect.stringContaining('exceeds the size limit'));
+    expect(replyMock).toHaveBeenCalledWith(
+      expect.objectContaining({
+        content: expect.stringContaining('exceeds the size limit'),
+        allowedMentions: { parse: [] },
+      })
+    );
 
     expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
       type: 'send-message',
@@ -523,6 +581,7 @@ describe('Discord Adapter Entry Point', () => {
 
     const mockReferencedMessage = {
       content: 'Would anyone like to get dinner Sunday?\nOr maybe lunch?',
+      author: { id: 'other-user', username: 'other_user' },
     };
 
     if (messageHandler) {
@@ -545,7 +604,8 @@ describe('Discord Adapter Entry Point', () => {
       type: 'send-message',
       client: 'cli',
       data: {
-        message: "> Would anyone like to get dinner Sunday?\n> Or maybe lunch?\nYes, I'm in!",
+        message:
+          "> **other_user said:**\n> Would anyone like to get dinner Sunday?\n> Or maybe lunch?\n\nYes, I'm in!",
         chatId: 'default',
         files: undefined,
         adapter: 'discord',
@@ -580,6 +640,7 @@ describe('Discord Adapter Entry Point', () => {
       const mockInteraction = {
         isButton: () => false,
         isModalSubmit: () => false,
+        isChatInputCommand: () => false,
       };
       if (interactionHandler) await interactionHandler(mockInteraction);
       expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
@@ -591,6 +652,7 @@ describe('Discord Adapter Entry Point', () => {
       const mockInteraction = {
         isButton: () => true,
         isModalSubmit: () => false,
+        isChatInputCommand: () => false,
         isRepliable: () => true,
         user: { id: 'unauth' },
         reply: vi.fn(),
@@ -607,6 +669,7 @@ describe('Discord Adapter Entry Point', () => {
       const mockInteraction = {
         isButton: () => true,
         isModalSubmit: () => false,
+        isChatInputCommand: () => false,
         user: { id: 'user-123' },
         customId: 'approve_123',
         update: vi.fn(),
@@ -634,6 +697,7 @@ describe('Discord Adapter Entry Point', () => {
       const mockInteraction = {
         isButton: () => true,
         isModalSubmit: () => false,
+        isChatInputCommand: () => false,
         user: { id: 'user-123' },
         customId: 'reject_123',
         showModal: vi.fn(),
@@ -646,6 +710,7 @@ describe('Discord Adapter Entry Point', () => {
       const mockInteraction = {
         isButton: () => false,
         isModalSubmit: () => true,
+        isChatInputCommand: () => false,
         isFromMessage: () => true,
         user: { id: 'user-123' },
         customId: 'modal_reject_123',

package/src/adapter-discord/index.ts

@@ -1,17 +1,16 @@
 #!/usr/bin/env node
 
-import { Client, Events, GatewayIntentBits, Partials } from 'discord.js';
-import { readDiscordConfig, isAuthorized, initDiscordConfig } from './config.js';
-import { readDiscordState, updateDiscordState } from './state.js';
+import { Client, Events, GatewayIntentBits, Partials, REST, Routes } from 'discord.js';
+import { readDiscordConfig, initDiscordConfig } from './config.js';
+import { readDiscordState } from './state.js';
 import { handleDiscordInteraction } from './interactions.js';
 import { getTRPCClient } from './client.js';
 import { startDaemonToDiscordForwarder } from './forwarder.js';
-import { getClawminiDir } from '../shared/workspace.js';
-import { handleAdapterCommand, type CommandTrpcClient } from '../shared/adapters/commands.js';
-import { formatMessage, type FilteringConfig } from '../shared/adapters/filtering.js';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { handleRoutingCommand, type RoutingTrpcClient } from '../shared/adapters/routing.js';
+import { slashCommands } from './commands.js';
+import { type CommandTrpcClient } from '../shared/adapters/commands.js';
+import { type FilteringConfig } from '../shared/adapters/filtering.js';
+
+import { processDiscordMessage } from './processMessage.js';
 
 export async function main() {
   const args = process.argv.slice(2);
@@ -46,238 +45,107 @@ export async function main() {
   const state = await readDiscordState();
   const filteringConfig: FilteringConfig = { filters: state.filters };
 
-  client.once(Events.ClientReady, (readyClient) => {
+  client.once(Events.ClientReady, async (readyClient) => {
     console.log(`Ready! Logged in as ${readyClient.user.tag}`);
 
+    // Workaround: pre-cache the authorized user's DM channel so inbound
+    // DMs aren't dropped before they reach the MessageCreate handler.
+    // discord.js >= 14.26 can't construct a partial DMChannel from a
+    // MESSAGE_CREATE payload (no `type`, no `recipients`), and the
+    // ChannelManager silently drops the dispatch when the channel isn't
+    // already in cache. Opening the DM here populates the cache so later
+    // events short-circuit to the existing entry.
+    // See: https://github.com/discordjs/discord.js/issues/11486
+    try {
+      const user = await readyClient.users.fetch(config.authorizedUserId);
+      await user.createDM();
+    } catch (err) {
+      console.error(
+        `Failed to pre-cache DM channel for authorized user ${config.authorizedUserId}:`,
+        err
+      );
+    }
+
+    try {
+      const rest = new REST({ version: '10' }).setToken(config.botToken);
+      console.log('Started refreshing application (/) commands.');
+      await rest.put(Routes.applicationCommands(readyClient.user.id), {
+        body: slashCommands.map((cmd) => cmd.toJSON()),
+      });
+      console.log('Successfully reloaded application (/) commands.');
+    } catch (error) {
+      console.error('Error registering slash commands:', error);
+    }
+
     // Start forwarding from daemon to Discord
     startDaemonToDiscordForwarder(readyClient, trpc, config.authorizedUserId, {
       chatId: config.chatId,
       config: filteringConfig,
+      discordConfig: config,
     }).catch((error) => {
       console.error('Error in daemon-to-discord forwarder:', error);
     });
   });
 
   client.on(Events.MessageCreate, async (message) => {
-    // Ignore messages from the bot itself
-    if (message.author.id === client.user?.id) return;
-    if (message.author.bot) return;
-
-    const externalContextId = message.channelId;
-    const currentState = await readDiscordState();
-    const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
-    const isRoutingCommand =
-      message.content.startsWith('/chat') || message.content.startsWith('/agent');
-
-    // Enforce requireMention config for guild messages
-    if (message.guild) {
-      const channelConfig = currentState.channelChatMap?.[externalContextId];
-      const requiresMention =
-        channelConfig?.requireMention !== undefined
-          ? channelConfig.requireMention
-          : config.requireMention;
-
-      if (requiresMention) {
-        const isMentioned = message.mentions.has(client.user!.id);
-        let isReplyToBot = false;
+    let isReplyToBot = false;
+    let referenceContent: string | undefined;
+    let referenceAuthor: string | undefined;
 
-        if (message.reference && message.reference.messageId) {
-          try {
-            const referencedMessage = await message.channel.messages.fetch(
-              message.reference.messageId
-            );
-            isReplyToBot = referencedMessage.author.id === client.user!.id;
-          } catch (err) {
-            console.error('Failed to fetch referenced message for mention check:', err);
+    if (message.reference && message.reference.messageId) {
+      try {
+        const referencedMessage = await message.fetchReference();
+        isReplyToBot = referencedMessage?.author.id === client.user!.id;
+        referenceContent = referencedMessage?.content;
+        if (referencedMessage) {
+          if (referencedMessage.author.bot) {
+            referenceAuthor = 'Assistant';
+          } else if (referencedMessage.author.id !== config.authorizedUserId) {
+            referenceAuthor = referencedMessage.author.username;
           }
         }
-
-        if (!isMentioned && !isReplyToBot) {
-          return;
-        }
-      }
-    }
-
-    // Check if the user is authorized
-    if (!isAuthorized(message.author.id, config.authorizedUserId)) {
-      console.log(
-        `Unauthorized message from ${message.author.tag} (${message.author.id}) ignored.`
-      );
-      return;
-    }
-
-    console.log(`Received message from ${message.author.tag}: ${message.content}`);
-
-    if (isRoutingCommand) {
-      const stringChatMap = Object.fromEntries(
-        Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ''])
-      );
-      const routingResult = await handleRoutingCommand(
-        message.content,
-        externalContextId,
-        stringChatMap,
-        'discord',
-        trpc as unknown as RoutingTrpcClient
-      );
-
-      if (routingResult) {
-        if (routingResult.type === 'mapped') {
-          await updateDiscordState((latestState) => ({
-            channelChatMap: {
-              ...(latestState.channelChatMap || {}),
-              [externalContextId]: {
-                ...(latestState.channelChatMap?.[externalContextId] || {}),
-                chatId: routingResult.newChatId,
-              },
-            },
-          }));
-        }
-        await message.reply(routingResult.text);
-        return;
-      }
-    }
-
-    let targetChatId = mappedChatId;
-
-    if (!targetChatId && !isRoutingCommand) {
-      const isFirstEverMessage =
-        !currentState.channelChatMap ||
-        Object.values(currentState.channelChatMap).every((entry) => !entry.chatId);
-
-      if (isFirstEverMessage) {
-        targetChatId = config.chatId || 'default';
-        console.log(
-          `First contact detected. Automatically mapping channel ${externalContextId} to chat ${targetChatId}.`
-        );
-        await updateDiscordState((latestState) => ({
-          channelChatMap: {
-            ...(latestState.channelChatMap || {}),
-            [externalContextId]: {
-              ...(latestState.channelChatMap?.[externalContextId] || {}),
-              chatId: targetChatId as string,
-            },
-          },
-        }));
-      } else {
-        const isDirectMessage = !message.guild;
-        const isMentioned = message.mentions.has(client.user!.id);
-        const isSlashCommand = message.content.startsWith('/');
-        if (isDirectMessage || isMentioned || isSlashCommand) {
-          console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
-          await message.reply(
-            'This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.'
-          );
-        } else {
-          console.log(
-            `Unmapped channel ${externalContextId}, silently ignoring background message.`
-          );
-        }
-        return;
+      } catch (err) {
+        console.error('Failed to fetch referenced message for mention check:', err);
       }
     }
 
-    // Fallback typing safeguard
-    if (!targetChatId) targetChatId = config.chatId || 'default';
+    const attachments = message.attachments
+      ? Array.from(message.attachments.values()).map((att) => ({
+          name: att.name,
+          size: att.size,
+          url: att.url,
+        }))
+      : [];
 
-    const commandResult = await handleAdapterCommand(
+    await processDiscordMessage(
       message.content,
+      message.author,
+      message.channelId,
+      message.guild,
+      async (text) => {
+        await message.reply({ content: text, allowedMentions: { parse: [] } });
+      },
+      config,
+      trpc,
       filteringConfig,
-      trpc as unknown as CommandTrpcClient,
-      targetChatId
-    );
-
-    if (commandResult) {
-      if (commandResult.type === 'text') {
-        if (commandResult.newConfig) {
-          filteringConfig.filters = commandResult.newConfig.filters;
-          await updateDiscordState({ filters: filteringConfig.filters });
-        }
-        await message.reply(commandResult.text);
-      } else if (commandResult.type === 'debug') {
-        const formatted =
-          commandResult.messages.length === 0
-            ? 'No ignored background messages found.'
-            : `**Debug Output (${commandResult.messages.length} ignored messages):**\n\n` +
-              commandResult.messages.map((msg) => formatMessage(msg)).join('\n\n---\n\n');
-        await message.reply(formatted);
+      {
+        mentionsBot: !!message.mentions?.has(client.user!.id),
+        isReplyToBot,
+        attachments,
+        messageId: message.id,
+        ...(referenceContent ? { referenceContent } : {}),
+        ...(referenceAuthor ? { referenceAuthor } : {}),
       }
-      return;
-    }
-
-    const downloadedFiles: string[] = [];
-    if (message.attachments.size > 0) {
-      const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'discord');
-      await fs.mkdir(tmpDir, { recursive: true });
-      const maxSizeMB = config.maxAttachmentSizeMB ?? 25;
-      const maxSizeBytes = maxSizeMB * 1024 * 1024;
-
-      for (const attachment of message.attachments.values()) {
-        if (attachment.size > maxSizeBytes) {
-          console.warn(
-            `Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`
-          );
-          await message.reply(
-            `Warning: Attachment ${attachment.name} exceeds the size limit of ${maxSizeMB}MB and was ignored.`
-          );
-          continue;
-        }
-
-        try {
-          const res = await fetch(attachment.url);
-          if (!res.ok) {
-            console.error(`Failed to download attachment ${attachment.name}`);
-            continue;
-          }
-
-          const uniqueName = `${Date.now()}-${attachment.name}`;
-          const filePath = path.join(tmpDir, uniqueName);
-          const arrayBuffer = await res.arrayBuffer();
-          await fs.writeFile(filePath, Buffer.from(arrayBuffer));
-          downloadedFiles.push(filePath);
-        } catch (err) {
-          console.error(`Error downloading attachment ${attachment.name}:`, err);
-        }
-      }
-    }
-
-    let finalContent = message.content;
-
-    if (message.reference && message.reference.messageId) {
-      try {
-        const referencedMessage = await message.fetchReference();
-        if (referencedMessage && referencedMessage.content) {
-          const quotedContent = referencedMessage.content
-            .split('\n')
-            .map((line) => `> ${line}`)
-            .join('\n');
-          finalContent = `${quotedContent}\n${finalContent}`;
-        }
-      } catch (err) {
-        console.error('Failed to fetch referenced message:', err);
-      }
-    }
-
-    console.log(`Forwarding message to daemon: ${finalContent}`);
-    try {
-      await trpc.sendMessage.mutate({
-        type: 'send-message',
-        client: 'cli',
-        data: {
-          message: finalContent,
-          chatId: targetChatId,
-          files: downloadedFiles.length > 0 ? downloadedFiles : undefined,
-          adapter: 'discord',
-          noWait: true,
-        },
-      });
-      console.log('Message forwarded to daemon successfully.');
-    } catch (error) {
-      console.error('Failed to forward message to daemon:', error);
-    }
+    );
   });
 
   client.on(Events.InteractionCreate, async (interaction) => {
-    await handleDiscordInteraction(interaction, config, trpc as unknown as CommandTrpcClient);
+    await handleDiscordInteraction(
+      interaction,
+      config,
+      trpc as unknown as CommandTrpcClient,
+      filteringConfig
+    );
   });
 
   try {

package/src/adapter-discord/interactions.test.ts

@@ -22,11 +22,16 @@ describe('handleDiscordInteraction', () => {
     mockInteraction = {
       isButton: vi.fn().mockReturnValue(true),
       isModalSubmit: vi.fn().mockReturnValue(false),
+      isChatInputCommand: vi.fn().mockReturnValue(false),
+      isRepliable: vi.fn().mockReturnValue(true),
       user: { id: 'user-1' },
       customId: '',
       channelId: 'channel-1',
       update: vi.fn().mockResolvedValue({}),
       followUp: vi.fn().mockResolvedValue({}),
+      reply: vi.fn().mockResolvedValue({}),
+      deferReply: vi.fn().mockResolvedValue({}),
+      deleteReply: vi.fn().mockResolvedValue({}),
       showModal: vi.fn().mockResolvedValue({}),
     };
     vi.mocked(readDiscordState).mockResolvedValue({});
@@ -43,7 +48,7 @@ describe('handleDiscordInteraction', () => {
 
   it('routes approve to explicit chat if provided', async () => {
     mockInteraction.customId = 'approve|policy-1|explicit-chat';
-    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc, { filters: {} });
 
     expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -59,7 +64,7 @@ describe('handleDiscordInteraction', () => {
     vi.mocked(readDiscordState).mockResolvedValue({
       channelChatMap: { 'channel-1': { chatId: 'mapped-chat' } },
     });
-    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc, { filters: {} });
 
     expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -83,7 +88,7 @@ describe('handleDiscordInteraction', () => {
       channelChatMap: { 'channel-1': { chatId: 'mapped-chat' } },
     });
 
-    await handleDiscordInteraction(mockInteraction, config, mockTrpc);
+    await handleDiscordInteraction(mockInteraction, config, mockTrpc, { filters: {} });
 
     expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
       expect.objectContaining({
@@ -93,4 +98,50 @@ describe('handleDiscordInteraction', () => {
       })
     );
   });
+
+  describe('chat input commands', () => {
+    beforeEach(() => {
+      mockInteraction.isButton.mockReturnValue(false);
+      mockInteraction.isModalSubmit.mockReturnValue(false);
+      mockInteraction.isChatInputCommand.mockReturnValue(true);
+      mockInteraction.options = {
+        getString: vi.fn(),
+      };
+    });
+
+    it('routes basic commands like /pending', async () => {
+      mockInteraction.commandName = 'pending';
+
+      await handleDiscordInteraction(mockInteraction, config, mockTrpc, { filters: {} });
+
+      expect(mockInteraction.deferReply).toHaveBeenCalledWith({ ephemeral: true });
+      expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({
+            message: '/pending',
+          }),
+        })
+      );
+    });
+
+    it('routes commands with arguments like /reject', async () => {
+      mockInteraction.commandName = 'reject';
+      mockInteraction.options.getString.mockImplementation((name: string) => {
+        if (name === 'policy_id') return 'req-123';
+        if (name === 'rationale') return 'too risky';
+        return null;
+      });
+
+      await handleDiscordInteraction(mockInteraction, config, mockTrpc, { filters: {} });
+
+      expect(mockInteraction.deferReply).toHaveBeenCalledWith({ ephemeral: true });
+      expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({
+            message: '/reject req-123 too risky',
+          }),
+        })
+      );
+    });
+  });
 });