clawmini 0.0.1

package/src/adapter-discord/forwarder.ts

@@ -0,0 +1,246 @@
+import type { Client, MessageCreateOptions } from 'discord.js';
+import path from 'node:path';
+import type { getTRPCClient } from './client.js';
+import { readDiscordState, writeDiscordState } from './state.js';
+import type { ChatMessage, CommandLogMessage } from '../shared/chats.js';
+import { getWorkspaceRoot } from '../shared/workspace.js';
+
+export async function startDaemonToDiscordForwarder(
+  client: Client,
+  trpc: ReturnType<typeof getTRPCClient>,
+  discordUserId: string,
+  chatId: string = 'default',
+  signal?: AbortSignal
+) {
+  const state = await readDiscordState();
+  let lastMessageId = state.lastSyncedMessageId;
+
+  // 1. If we don't have a lastMessageId, get the most recent one from the daemon
+  // to avoid sending the entire chat history on first run.
+  if (!lastMessageId) {
+    try {
+      const messages = await trpc.getMessages.query({ chatId, limit: 1 });
+      if (Array.isArray(messages) && messages.length > 0) {
+        const lastMsg = messages[messages.length - 1];
+        if (lastMsg) {
+          lastMessageId = lastMsg.id;
+          await writeDiscordState({ lastSyncedMessageId: lastMessageId });
+        }
+      }
+    } catch (error) {
+      if (signal?.aborted) return;
+      console.error('Failed to fetch initial messages from daemon:', error);
+    }
+  }
+
+  console.log(
+    `Starting daemon-to-discord forwarder for chat ${chatId}, lastMessageId: ${lastMessageId}`
+  );
+
+  let retryDelay = 1000;
+  const maxRetryDelay = 30000;
+
+  // 2. Start the observation loop using tRPC subscription
+  return new Promise<void>((resolve) => {
+    let subscription: { unsubscribe: () => void } | null = null;
+    let messageQueue = Promise.resolve();
+
+    const connect = () => {
+      if (signal?.aborted) {
+        resolve();
+        return;
+      }
+
+      subscription = trpc.waitForMessages.subscribe(
+        { chatId, lastMessageId },
+        {
+          onData: (messages) => {
+            retryDelay = 1000; // Reset retry delay on successful data
+
+            if (!Array.isArray(messages) || messages.length === 0) {
+              return;
+            }
+
+            // Queue processing to ensure sequential execution
+            messageQueue = messageQueue.then(async () => {
+              for (const rawMessage of messages) {
+                if (signal?.aborted) break;
+
+                const message = rawMessage as ChatMessage;
+
+                // Only forward logs (agent responses, system messages)
+                if (message.role === 'log') {
+                  const logMessage = message as CommandLogMessage;
+
+                  if (logMessage.level === 'verbose') {
+                    lastMessageId = logMessage.id;
+                    await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(
+                      console.error
+                    );
+                    continue;
+                  }
+
+                  const hasContent = !!logMessage.content?.trim();
+                  const hasFiles = Array.isArray(logMessage.files) && logMessage.files.length > 0;
+
+                  // The daemon stores logMessage.files as paths relative to the WORKSPACE directory
+                  // (the directory containing .clawmini). We must resolve these against the current
+                  // workspace root so discord.js can successfully locate and read the files.
+                  let absoluteFiles: string[] = [];
+                  if (hasFiles) {
+                    const workspaceRoot = getWorkspaceRoot(process.cwd());
+                    absoluteFiles = logMessage.files!.map((f) => path.resolve(workspaceRoot, f));
+                  }
+
+                  if (!hasContent && !hasFiles) {
+                    lastMessageId = logMessage.id;
+                    await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(
+                      console.error
+                    );
+                    continue;
+                  }
+
+                  try {
+                    const user = await client.users.fetch(discordUserId);
+                    const dm = await user.createDM();
+
+                    // Discord has a 2000 character limit for messages.
+                    if (hasContent && logMessage.content.length > 2000) {
+                      const chunks = chunkString(logMessage.content, 2000);
+                      for (let i = 0; i < chunks.length; i++) {
+                        if (signal?.aborted) break;
+                        const chunkOptions: MessageCreateOptions = { content: chunks[i] as string };
+                        if (i === chunks.length - 1 && hasFiles) {
+                          chunkOptions.files = absoluteFiles;
+                        }
+                        await dm.send(chunkOptions);
+                      }
+                    } else {
+                      const options: MessageCreateOptions = {};
+                      if (hasContent) {
+                        options.content = logMessage.content;
+                      }
+                      if (hasFiles) {
+                        options.files = absoluteFiles;
+                      }
+                      await dm.send(options);
+                    }
+                  } catch (error) {
+                    console.error(
+                      `Failed to send message to Discord user ${discordUserId}:`,
+                      error
+                    );
+                    // We don't advance lastMessageId if sending failed
+                    break;
+                  }
+                }
+
+                lastMessageId = message.id;
+                await writeDiscordState({ lastSyncedMessageId: lastMessageId }).catch(
+                  console.error
+                );
+              }
+            });
+          },
+          onError: (error) => {
+            console.error(
+              `Error in daemon-to-discord forwarder subscription. Retrying in ${retryDelay}ms.`,
+              error
+            );
+            subscription?.unsubscribe();
+            subscription = null;
+
+            if (signal?.aborted) {
+              resolve();
+              return;
+            }
+
+            setTimeout(() => {
+              retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+              connect();
+            }, retryDelay);
+          },
+          onComplete: () => {
+            subscription = null;
+            if (!signal?.aborted) {
+              setTimeout(() => connect(), retryDelay);
+            } else {
+              resolve();
+            }
+          },
+        }
+      );
+    };
+
+    let typingSubscription: { unsubscribe: () => void } | null = null;
+    let typingRetryDelay = 1000;
+
+    const connectTyping = () => {
+      if (signal?.aborted) {
+        return;
+      }
+
+      typingSubscription = trpc.waitForTyping.subscribe(
+        { chatId },
+        {
+          onData: async (event) => {
+            typingRetryDelay = 1000; // Reset retry delay on successful data
+            if (!event) return;
+
+            try {
+              const user = await client.users.fetch(discordUserId);
+              const dm = await user.createDM();
+              await dm.sendTyping();
+            } catch (error) {
+              console.error(
+                `Failed to send typing indicator to Discord user ${discordUserId}:`,
+                error
+              );
+            }
+          },
+          onError: (error) => {
+            console.error(
+              `Error in daemon-to-discord typing forwarder subscription. Retrying in ${typingRetryDelay}ms.`,
+              error
+            );
+            typingSubscription?.unsubscribe();
+            typingSubscription = null;
+
+            if (signal?.aborted) {
+              return;
+            }
+
+            setTimeout(() => {
+              typingRetryDelay = Math.min(typingRetryDelay * 2, maxRetryDelay);
+              connectTyping();
+            }, typingRetryDelay);
+          },
+          onComplete: () => {
+            typingSubscription = null;
+            if (!signal?.aborted) {
+              setTimeout(() => connectTyping(), typingRetryDelay);
+            }
+          },
+        }
+      );
+    };
+
+    connect();
+    connectTyping();
+
+    signal?.addEventListener('abort', () => {
+      subscription?.unsubscribe();
+      typingSubscription?.unsubscribe();
+      resolve();
+    });
+  });
+}
+
+function chunkString(str: string, size: number): string[] {
+  const chunks: string[] = [];
+  const chars = Array.from(str);
+  for (let i = 0; i < chars.length; i += size) {
+    chunks.push(chars.slice(i, i + size).join(''));
+  }
+  return chunks;
+}

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

@@ -0,0 +1,399 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { readDiscordConfig } from './config.js';
+import { getTRPCClient } from './client.js';
+
+// Mock the modules
+const { mockClientInstance } = vi.hoisted(() => ({
+  mockClientInstance: {
+    once: vi.fn(),
+    on: vi.fn(),
+    login: vi.fn().mockResolvedValue('token'),
+    user: { id: 'bot-id', tag: 'bot#1234' },
+  },
+}));
+
+vi.mock('discord.js', () => {
+  return {
+    Client: class {
+      constructor() {
+        return mockClientInstance;
+      }
+    },
+    Events: {
+      ClientReady: 'ready',
+      MessageCreate: 'messageCreate',
+    },
+    GatewayIntentBits: {
+      Guilds: 1,
+      DirectMessages: 2,
+      MessageContent: 3,
+    },
+    Partials: {
+      Channel: 1,
+    },
+  };
+});
+
+vi.mock('./config.js', () => ({
+  readDiscordConfig: vi.fn(),
+  initDiscordConfig: vi.fn(),
+  isAuthorized: vi.fn(),
+}));
+
+vi.mock('./client.js', () => ({
+  getTRPCClient: vi.fn(),
+}));
+
+describe('Discord Adapter Entry Point', () => {
+  let mockTrpc: ReturnType<typeof import('./client.js').getTRPCClient>;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockTrpc = {
+      sendMessage: {
+        mutate: vi.fn().mockResolvedValue({ success: true }),
+      },
+    } as unknown as ReturnType<typeof import('./client.js').getTRPCClient>;
+    vi.mocked(getTRPCClient).mockReturnValue(mockTrpc);
+    vi.mocked(readDiscordConfig).mockResolvedValue({
+      botToken: 'test-token',
+      authorizedUserId: 'user-123',
+      chatId: 'default',
+    });
+
+    // Reset the mock implementation to return the instance
+    vi.mocked(mockClientInstance.on).mockReturnValue(mockClientInstance);
+    vi.mocked(mockClientInstance.once).mockReturnValue(mockClientInstance);
+  });
+
+  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');
+    const { main } = await import('./index.js');
+    await main();
+
+    expect(initDiscordConfig).toHaveBeenCalled();
+    expect(vi.mocked(mockClientInstance.login)).not.toHaveBeenCalled();
+    process.argv = []; // reset
+  });
+
+  it('should initialize Discord client and forward authorized DM messages', async () => {
+    vi.useFakeTimers();
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    expect(vi.mocked(mockClientInstance.login)).toHaveBeenCalledWith('test-token');
+    expect(messageHandler).toBeDefined();
+
+    const mockMessage = {
+      author: { id: 'user-123', tag: 'user#1234' },
+      content: 'Hello daemon!',
+      guild: null,
+      attachments: new Map(),
+    };
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    if (messageHandler) {
+      await messageHandler(mockMessage as unknown as import('discord.js').Message);
+    }
+
+    // Fast-forward time for debouncer
+    await vi.runAllTimersAsync();
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+      type: 'send-message',
+      client: 'cli',
+      data: {
+        message: 'Hello daemon!',
+        chatId: 'default',
+        files: undefined,
+        adapter: 'discord',
+        noWait: true,
+      },
+    });
+    vi.useRealTimers();
+  });
+
+  it('should ignore duplicate network events based on Discord message ID', async () => {
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    if (messageHandler) {
+      await messageHandler({
+        id: 'msg-1',
+        author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
+        content: 'message 1',
+        guild: null,
+        attachments: new Map(),
+      } as unknown as import('discord.js').Message);
+      await messageHandler({
+        id: 'msg-2',
+        author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
+        content: 'message 2',
+        guild: null,
+        attachments: new Map(),
+      } as unknown as import('discord.js').Message);
+    }
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledTimes(2);
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenNthCalledWith(1, {
+      type: 'send-message',
+      client: 'cli',
+      data: {
+        message: 'message 1',
+        chatId: 'default',
+        files: undefined,
+        adapter: 'discord',
+        noWait: true,
+      },
+    });
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenNthCalledWith(2, {
+      type: 'send-message',
+      client: 'cli',
+      data: {
+        message: 'message 2',
+        chatId: 'default',
+        files: undefined,
+        adapter: 'discord',
+        noWait: true,
+      },
+    });
+  });
+
+  it('should ignore unauthorized messages', async () => {
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const mockMessage = {
+      author: { id: 'user-evil', tag: 'evil#666' },
+      content: 'Hack the daemon!',
+      guild: null,
+    };
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(false);
+
+    if (messageHandler) {
+      await messageHandler(mockMessage as unknown as import('discord.js').Message);
+    }
+
+    expect(mockTrpc.sendMessage.mutate).not.toHaveBeenCalled();
+  });
+
+  it('should download attachments and forward their paths', async () => {
+    vi.useFakeTimers();
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    const attachments = new Map();
+    attachments.set('1', { name: 'test.txt', url: 'http://example.com/test.txt', size: 100 });
+
+    const fsPromises = await import('node:fs/promises');
+    vi.spyOn(fsPromises.default, 'mkdir').mockResolvedValue(undefined);
+    vi.spyOn(fsPromises.default, 'writeFile').mockResolvedValue(undefined);
+
+    const mockResponse = {
+      ok: true,
+      arrayBuffer: vi.fn().mockResolvedValue(new ArrayBuffer(8)),
+    } as unknown as Response;
+    global.fetch = vi.fn().mockResolvedValue(mockResponse);
+
+    if (messageHandler) {
+      await messageHandler({
+        author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
+        content: 'Check out this file',
+        guild: null,
+        attachments,
+      } as unknown as import('discord.js').Message);
+    }
+
+    // Fast-forward time for debouncer
+    await vi.runAllTimersAsync();
+
+    expect(global.fetch).toHaveBeenCalledWith('http://example.com/test.txt');
+    expect(fsPromises.default.writeFile).toHaveBeenCalled();
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+      type: 'send-message',
+      client: 'cli',
+      data: expect.objectContaining({
+        message: 'Check out this file',
+        chatId: 'default',
+        files: expect.arrayContaining([expect.stringContaining('test.txt')]),
+      }),
+    });
+
+    vi.useRealTimers();
+  });
+
+  it('should ignore attachments that exceed the size limit', async () => {
+    vi.useFakeTimers();
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    const attachments = new Map();
+    // 26MB is over the 25MB default
+    attachments.set('1', {
+      name: 'huge.txt',
+      url: 'http://example.com/huge.txt',
+      size: 26 * 1024 * 1024 + 1,
+    });
+
+    global.fetch = vi.fn();
+
+    const replyMock = vi.fn();
+
+    if (messageHandler) {
+      await messageHandler({
+        author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
+        content: 'Check out this huge file',
+        guild: null,
+        attachments,
+        reply: replyMock,
+      } as unknown as import('discord.js').Message);
+    }
+
+    // Fast-forward time for debouncer
+    await vi.runAllTimersAsync();
+
+    expect(global.fetch).not.toHaveBeenCalled();
+    expect(replyMock).toHaveBeenCalledWith(expect.stringContaining('exceeds the size limit'));
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+      type: 'send-message',
+      client: 'cli',
+      data: {
+        message: 'Check out this huge file',
+        chatId: 'default',
+        files: undefined, // no files should be attached
+        adapter: 'discord',
+        noWait: true,
+      },
+    });
+
+    vi.useRealTimers();
+  });
+
+  it('should format message with blockquote when it is a reply', async () => {
+    vi.useFakeTimers();
+    let messageHandler: ((message: import('discord.js').Message) => Promise<void>) | undefined;
+    vi.mocked(mockClientInstance.on).mockImplementation(
+      (event: string, cb: (...args: unknown[]) => void) => {
+        if (event === 'messageCreate') {
+          messageHandler = cb as unknown as (
+            message: import('discord.js').Message
+          ) => Promise<void>;
+        }
+        return mockClientInstance as unknown as import('discord.js').Client;
+      }
+    );
+
+    const { main } = await import('./index.js');
+    await main();
+
+    const { isAuthorized } = await import('./config.js');
+    vi.mocked(isAuthorized).mockReturnValue(true);
+
+    const mockReferencedMessage = {
+      content: 'Would anyone like to get dinner Sunday?\nOr maybe lunch?',
+    };
+
+    if (messageHandler) {
+      await messageHandler({
+        author: { id: 'user-123', tag: 'user#1234' } as unknown as import('discord.js').User,
+        content: "Yes, I'm in!",
+        guild: null,
+        attachments: new Map(),
+        reference: { messageId: '12345' },
+        fetchReference: vi.fn().mockResolvedValue(mockReferencedMessage),
+      } as unknown as import('discord.js').Message);
+    }
+
+    // Fast-forward time for debouncer
+    await vi.runAllTimersAsync();
+
+    expect(mockTrpc.sendMessage.mutate).toHaveBeenCalledWith({
+      type: 'send-message',
+      client: 'cli',
+      data: {
+        message: "> Would anyone like to get dinner Sunday?\n> Or maybe lunch?\nYes, I'm in!",
+        chatId: 'default',
+        files: undefined,
+        adapter: 'discord',
+        noWait: true,
+      },
+    });
+    vi.useRealTimers();
+  });
+});