clawmini 0.0.8 → 0.0.9

package/src/adapter-discord/interactions.ts

@@ -5,8 +5,10 @@ import {
   TextInputStyle,
   type Interaction,
 } from 'discord.js';
-import { readDiscordState } from './state.js';
 import type { DiscordConfig } from './config.js';
+import { readDiscordState } from './state.js';
+import { type FilteringConfig } from '../shared/adapters/filtering.js';
+import { processDiscordMessage } from './processMessage.js';
 
 function isAuthorized(userId: string, authorizedUserId: string): boolean {
   return userId === authorizedUserId;
@@ -16,9 +18,16 @@ export async function handleDiscordInteraction(
   interaction: Interaction,
   config: DiscordConfig,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  trpc: any
+  trpc: any,
+  filteringConfig: FilteringConfig
 ) {
-  if (!interaction.isButton() && !interaction.isModalSubmit()) return;
+  if (
+    !interaction.isButton() &&
+    !interaction.isModalSubmit() &&
+    !interaction.isChatInputCommand()
+  ) {
+    return;
+  }
 
   if (!isAuthorized(interaction.user.id, config.authorizedUserId)) {
     if (interaction.isRepliable()) {
@@ -30,6 +39,48 @@ export async function handleDiscordInteraction(
     return;
   }
 
+  if (interaction.isChatInputCommand()) {
+    const { commandName } = interaction;
+    let commandStr = `/${commandName}`;
+
+    if (commandName === 'approve' || commandName === 'reject') {
+      const policyId = interaction.options.getString('policy_id');
+      if (policyId) commandStr += ` ${policyId}`;
+    }
+    if (commandName === 'reject') {
+      const rationale = interaction.options.getString('rationale');
+      if (rationale) commandStr += ` ${rationale}`;
+    }
+
+    await interaction.deferReply({ ephemeral: true });
+
+    const currentState = await readDiscordState();
+    const targetChatId = interaction.channelId
+      ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId
+      : config.chatId;
+
+    let replied = false;
+    await processDiscordMessage(
+      commandStr,
+      interaction.user,
+      interaction.channelId,
+      interaction.guild,
+      async (text) => {
+        replied = true;
+        await interaction.followUp({ content: text, ephemeral: true });
+      },
+      config,
+      trpc,
+      filteringConfig,
+      { explicitChatId: targetChatId, mentionsBot: true }
+    );
+
+    if (!replied) {
+      await interaction.deleteReply();
+    }
+    return;
+  }
+
   if (interaction.isButton()) {
     if (
       interaction.customId.startsWith('approve_') ||
@@ -46,30 +97,27 @@ export async function handleDiscordInteraction(
 
       await interaction.update({ components: [] });
       await interaction.followUp({ content: `Approving policy ${policyId}...`, ephemeral: true });
-      try {
-        const currentState = await readDiscordState();
-        const targetChatId =
-          explicitChatId ||
-          (interaction.channelId
-            ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId
-            : config.chatId);
-        await trpc.sendMessage.mutate({
-          type: 'send-message',
-          client: 'cli',
-          data: {
-            message: `/approve ${policyId}`,
-            chatId: targetChatId,
-            adapter: 'discord',
-            noWait: true,
-          },
-        });
-      } catch (error) {
-        console.error('Failed to send approve command to daemon:', error);
-        await interaction.followUp({
-          content: `Failed to approve policy ${policyId}.`,
-          ephemeral: true,
-        });
-      }
+
+      const currentState = await readDiscordState();
+      const targetChatId =
+        explicitChatId ||
+        (interaction.channelId
+          ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId
+          : config.chatId);
+
+      await processDiscordMessage(
+        `/approve ${policyId}`,
+        interaction.user,
+        interaction.channelId,
+        interaction.guild,
+        async (text) => {
+          await interaction.followUp({ content: text, ephemeral: true });
+        },
+        config,
+        trpc,
+        filteringConfig,
+        { explicitChatId: targetChatId, mentionsBot: true }
+      );
     } else if (
       interaction.customId.startsWith('reject_') ||
       interaction.customId.startsWith('reject|')
@@ -123,34 +171,30 @@ export async function handleDiscordInteraction(
           ephemeral: true,
         });
       } else {
-        await interaction.reply({ content: `Rejecting policy ${policyId}...`, ephemeral: true });
+        await interaction.deferReply({ ephemeral: true });
+        await interaction.followUp({ content: `Rejecting policy ${policyId}...`, ephemeral: true });
       }
 
-      try {
-        const currentState = await readDiscordState();
-        const targetChatId =
-          explicitChatId ||
-          (interaction.channelId
-            ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId
-            : config.chatId);
-
-        await trpc.sendMessage.mutate({
-          type: 'send-message',
-          client: 'cli',
-          data: {
-            message: command,
-            chatId: targetChatId,
-            adapter: 'discord',
-            noWait: true,
-          },
-        });
-      } catch (error) {
-        console.error('Failed to send reject command to daemon:', error);
-        await interaction.followUp({
-          content: `Failed to reject policy ${policyId}.`,
-          ephemeral: true,
-        });
-      }
+      const currentState = await readDiscordState();
+      const targetChatId =
+        explicitChatId ||
+        (interaction.channelId
+          ? currentState.channelChatMap?.[interaction.channelId]?.chatId || config.chatId
+          : config.chatId);
+
+      await processDiscordMessage(
+        command,
+        interaction.user,
+        interaction.channelId,
+        interaction.guild,
+        async (text) => {
+          await interaction.followUp({ content: text, ephemeral: true });
+        },
+        config,
+        trpc,
+        filteringConfig,
+        { explicitChatId: targetChatId, mentionsBot: true }
+      );
     }
   }
 }

package/src/adapter-discord/processMessage.ts

@@ -0,0 +1,239 @@
+import { readDiscordState, updateDiscordState } from './state.js';
+import type { DiscordConfig } from './config.js';
+import { recordInbound } from './inbound-cache.js';
+import { handleAdapterCommand, type CommandTrpcClient } from '../shared/adapters/commands.js';
+import { formatMessage, type FilteringConfig } from '../shared/adapters/filtering.js';
+import { handleRoutingCommand, type RoutingTrpcClient } from '../shared/adapters/routing.js';
+import { prependBlockquote } from '../shared/adapters/blockquote.js';
+import { getClawminiDir } from '../shared/workspace.js';
+import path from 'node:path';
+import fs from 'node:fs/promises';
+
+export type ProcessMessageOptions = {
+  mentionsBot?: boolean;
+  isReplyToBot?: boolean;
+  attachments?: { name: string; size: number; url: string }[];
+  referenceContent?: string;
+  referenceAuthor?: string;
+  explicitChatId?: string;
+  /**
+   * Discord message id of the inbound. Recorded in the in-memory inbound
+   * cache and sent to the daemon as `externalRef` so the forwarder can
+   * resolve the user's message and start a Discord thread anchored on it
+   * when `turnStarted` arrives.
+   */
+  messageId?: string;
+};
+
+export async function processDiscordMessage(
+  content: string,
+  author: { id: string; tag: string; bot?: boolean },
+  channelId: string | null,
+  guild: unknown | null,
+  reply: (text: string) => Promise<unknown>,
+  config: DiscordConfig,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  trpc: any,
+  filteringConfig: FilteringConfig,
+  options: ProcessMessageOptions = {}
+) {
+  if (author.bot) return;
+
+  const externalContextId = channelId || 'default';
+  const currentState = await readDiscordState();
+  const mappedChatId =
+    options.explicitChatId || (channelId ? currentState.channelChatMap?.[channelId]?.chatId : null);
+  const isRoutingCommand = content.startsWith('/chat') || content.startsWith('/agent');
+
+  // Enforce requireMention config for guild messages
+  if (guild && channelId) {
+    const channelConfig = currentState.channelChatMap?.[channelId];
+    const requiresMention =
+      channelConfig?.requireMention !== undefined
+        ? channelConfig.requireMention
+        : config.requireMention;
+
+    if (requiresMention) {
+      if (!options.mentionsBot && !options.isReplyToBot) {
+        return;
+      }
+    }
+  }
+
+  function isAuthorized(userId: string, authorizedUserId: string): boolean {
+    return userId === authorizedUserId;
+  }
+
+  // Check if the user is authorized
+  if (!isAuthorized(author.id, config.authorizedUserId)) {
+    console.log(`Unauthorized message from ${author.tag} (${author.id}) ignored.`);
+    return;
+  }
+
+  console.log(`Received message from ${author.tag}: ${content}`);
+
+  if (isRoutingCommand) {
+    const stringChatMap = Object.fromEntries(
+      Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ''])
+    );
+    const routingResult = await handleRoutingCommand(
+      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 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 = !guild;
+      const isSlashCommand = content.startsWith('/');
+      if (isDirectMessage || options.mentionsBot || isSlashCommand) {
+        console.log(`Unmapped channel ${externalContextId}, sending first contact warning.`);
+        await 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;
+    }
+  }
+
+  // Fallback typing safeguard
+  if (!targetChatId) targetChatId = config.chatId || 'default';
+
+  const commandResult = await handleAdapterCommand(
+    content,
+    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 reply(commandResult.text);
+    } else if (commandResult.type === 'debug') {
+      // Debug output echoes raw message content (which may include @everyone /
+      // @here as a substring). The `reply` lambda already strips mentions, so
+      // there's no extra escaping to do here.
+      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 reply(formatted);
+    }
+    return;
+  }
+
+  const downloadedFiles: string[] = [];
+  if (options.attachments && options.attachments.length > 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 options.attachments) {
+      if (attachment.size > maxSizeBytes) {
+        console.warn(
+          `Attachment ${attachment.name} exceeds size limit (${maxSizeMB}MB). Ignoring.`
+        );
+        await 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 = content;
+
+  if (options.referenceContent) {
+    finalContent = prependBlockquote(
+      options.referenceContent,
+      finalContent,
+      options.referenceAuthor
+    );
+  }
+
+  console.log(`Forwarding message to daemon: ${finalContent}`);
+  if (options.messageId && channelId) {
+    recordInbound({ messageId: options.messageId, channelId });
+  }
+  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,
+        ...(options.messageId ? { externalRef: options.messageId } : {}),
+      },
+    });
+    console.log('Message forwarded to daemon successfully.');
+  } catch (error) {
+    console.error('Failed to forward message to daemon:', error);
+    await reply('Failed to forward message to the daemon. Please check the logs.');
+  }
+}

package/src/adapter-discord/state.ts

@@ -11,6 +11,7 @@ export const DiscordStateSchema = z.object({
       z.object({
         chatId: z.string().nullable().optional(),
         requireMention: z.boolean().optional(),
+        threadsDisabled: z.boolean().optional(),
       })
     )
     .optional(),

package/src/adapter-google-chat/auth.test.ts

@@ -71,17 +71,21 @@ describe('auth.ts', () => {
     const newTokens = { access_token: 'new_token' };
     await tokenCallback(newTokens);
 
-    expect(state.updateGoogleChatState).toHaveBeenCalledWith({
-      oauthTokens: {
-        access_token: 'new_token',
+    expect(state.updateGoogleChatState).toHaveBeenCalledWith(
+      {
+        oauthTokens: {
+          access_token: 'new_token',
+        },
       },
-    });
+      expect.any(String)
+    );
 
     expect(state.updateGoogleChatState).not.toHaveBeenCalledWith(
       expect.objectContaining({
         lastSyncedMessageIds: { default: '123' },
         activeSpaceName: 'Space1',
-      })
+      }),
+      expect.any(String)
     );
   });
 });

package/src/adapter-google-chat/auth.ts

@@ -13,12 +13,14 @@ export async function getAuthClient() {
   return authClient;
 }
 
-let userAuthClient: InstanceType<typeof google.auth.OAuth2> | null = null;
-let userAuthPromise: Promise<InstanceType<typeof google.auth.OAuth2>> | null = null;
+const userAuthClients = new Map<string, InstanceType<typeof google.auth.OAuth2>>();
+const userAuthPromises = new Map<string, Promise<InstanceType<typeof google.auth.OAuth2>>>();
 
-export async function getUserAuthClient(config: GoogleChatConfig) {
-  if (userAuthClient) return userAuthClient;
-  if (userAuthPromise) return userAuthPromise;
+export async function getUserAuthClient(config: GoogleChatConfig, startDir = process.cwd()) {
+  const cached = userAuthClients.get(startDir);
+  if (cached) return cached;
+  const pending = userAuthPromises.get(startDir);
+  if (pending) return pending;
 
   if (!config.oauthClientId || !config.oauthClientSecret) {
     console.error('DEBUG config:', config);
@@ -27,7 +29,7 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
     );
   }
 
-  userAuthPromise = (async () => {
+  const promise = (async () => {
     const oauth2Client = new google.auth.OAuth2(
       config.oauthClientId,
       config.oauthClientSecret,
@@ -36,23 +38,26 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
 
     oauth2Client.on('tokens', async (tokens) => {
       try {
-        const currentState = await readGoogleChatState();
-        await updateGoogleChatState({
-          oauthTokens: {
-            ...currentState.oauthTokens,
-            ...tokens,
+        const currentState = await readGoogleChatState(startDir);
+        await updateGoogleChatState(
+          {
+            oauthTokens: {
+              ...currentState.oauthTokens,
+              ...tokens,
+            },
           },
-        });
+          startDir
+        );
       } catch (err) {
         console.error('Failed to save refreshed Google User tokens', err);
       }
     });
 
-    const state = await readGoogleChatState();
+    const state = await readGoogleChatState(startDir);
     if (state.oauthTokens) {
       oauth2Client.setCredentials(state.oauthTokens);
-      userAuthClient = oauth2Client;
-      userAuthPromise = null;
+      userAuthClients.set(startDir, oauth2Client);
+      userAuthPromises.delete(startDir);
       return oauth2Client;
     }
 
@@ -86,22 +91,22 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
               const { tokens } = await oauth2Client.getToken(code);
               oauth2Client.setCredentials(tokens);
 
-              await updateGoogleChatState({ oauthTokens: tokens });
+              await updateGoogleChatState({ oauthTokens: tokens }, startDir);
 
               console.log('Google User authorization successful!');
-              userAuthClient = oauth2Client;
-              userAuthPromise = null;
+              userAuthClients.set(startDir, oauth2Client);
+              userAuthPromises.delete(startDir);
               resolve(oauth2Client);
             } catch (err) {
               console.error('Failed to get token', err);
-              userAuthPromise = null;
+              userAuthPromises.delete(startDir);
               reject(err);
             }
           } else {
             res.end('Authentication failed!');
             clearTimeout(timeoutId);
             server.close();
-            userAuthPromise = null;
+            userAuthPromises.delete(startDir);
             reject(new Error('No code provided in OAuth callback'));
           }
         }
@@ -110,7 +115,7 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
       server.on('error', (err) => {
         console.error('Failed to start local OAuth server on port 31338', err);
         clearTimeout(timeoutId);
-        userAuthPromise = null;
+        userAuthPromises.delete(startDir);
         reject(err);
       });
 
@@ -118,7 +123,7 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
         timeoutId = setTimeout(
           () => {
             server.close();
-            userAuthPromise = null;
+            userAuthPromises.delete(startDir);
             console.error('Google User authorization timed out after 5 minutes.');
             reject(new Error('Google User authorization timed out.'));
           },
@@ -128,5 +133,6 @@ export async function getUserAuthClient(config: GoogleChatConfig) {
     });
   })();
 
-  return userAuthPromise;
+  userAuthPromises.set(startDir, promise);
+  return promise;
 }

package/src/adapter-google-chat/cards.ts

@@ -2,11 +2,14 @@ import { google } from 'googleapis';
 import { getAuthClient } from './auth.js';
 import type { RoutingTrpcClient } from '../shared/adapters/routing.js';
 
+type ChatApiLike = ReturnType<typeof google.chat>;
+
 export async function handleCardClicked(
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   event: any,
   targetChatId: string,
-  trpc: RoutingTrpcClient
+  trpc: RoutingTrpcClient,
+  getChatApi?: () => Promise<ChatApiLike>
 ) {
   const action = event.action;
   if (!action) return;
@@ -22,7 +25,9 @@ export async function handleCardClicked(
 
     if (event.message?.name) {
       try {
-        const chatApi = google.chat({ version: 'v1', auth: await getAuthClient() });
+        const chatApi = getChatApi
+          ? await getChatApi()
+          : google.chat({ version: 'v1', auth: await getAuthClient() });
 
         const originalCards = event.message.cardsV2 || [];
         // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/adapter-google-chat/client.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { getTRPCClient, startGoogleChatIngestion } from './client.js';
+import { formatQuotedSender, getTRPCClient, startGoogleChatIngestion } from './client.js';
 import fs from 'node:fs';
 import fsPromises from 'node:fs/promises';
 import * as workspace from '../shared/workspace.js';
@@ -87,6 +87,41 @@ describe('Google Chat Adapter Client', () => {
     vi.clearAllMocks();
   });
 
+  describe('formatQuotedSender', () => {
+    const authorized = ['user@example.com', 'users/42'];
+
+    it('returns undefined when sender is missing', () => {
+      expect(formatQuotedSender(undefined, authorized)).toBeUndefined();
+    });
+
+    it('labels bots as "Assistant"', () => {
+      expect(formatQuotedSender({ type: 'BOT' }, authorized)).toBe('Assistant');
+    });
+
+    it('returns undefined for authorized users by email', () => {
+      expect(
+        formatQuotedSender({ email: 'user@example.com', type: 'HUMAN' }, authorized)
+      ).toBeUndefined();
+    });
+
+    it('returns undefined for authorized users by user resource name', () => {
+      expect(formatQuotedSender({ name: 'users/42', type: 'HUMAN' }, authorized)).toBeUndefined();
+    });
+
+    it('falls back to email for other people', () => {
+      expect(
+        formatQuotedSender(
+          { email: 'other@example.com', name: 'users/9', type: 'HUMAN' },
+          authorized
+        )
+      ).toBe('other@example.com');
+    });
+
+    it('falls back to user resource name when email is absent', () => {
+      expect(formatQuotedSender({ name: 'users/9', type: 'HUMAN' }, authorized)).toBe('users/9');
+    });
+  });
+
   describe('getTRPCClient', () => {
     it('should throw error if daemon socket does not exist', () => {
       vi.mocked(workspace.getSocketPath).mockReturnValue('/tmp/test.sock');
@@ -533,7 +568,7 @@ describe('Google Chat Adapter Client', () => {
 
       vi.mocked(google.chat({ version: 'v1' }).spaces.messages.list).mockResolvedValueOnce({
         data: { messages: [{ sender: { type: 'BOT' } }] },
-      } as any);
+      } as never);
 
       const mockMsg = {
         data: Buffer.from(