clawmini 0.0.7 → 0.0.9

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

@@ -13,12 +13,14 @@ import { createUnixSocketEventSource } from '../shared/event-source.js';
 import type { GoogleChatConfig } from './config.js';
 import { isAuthorized, updateGoogleChatConfig } from './config.js';
 import { readGoogleChatState, updateGoogleChatState } from './state.js';
-import { downloadAttachment } from './utils.js';
+import { recordInbound } from './inbound-cache.js';
+import { downloadAttachment as defaultDownloadAttachment } from './utils.js';
 import { handleAdapterCommand, type CommandTrpcClient } from '../shared/adapters/commands.js';
 import { formatMessage, type FilteringConfig } from '../shared/adapters/filtering.js';
 import { google } from 'googleapis';
 import { getAuthClient } from './auth.js';
 import { handleRoutingCommand, type RoutingTrpcClient } from '../shared/adapters/routing.js';
+import { prependBlockquote } from '../shared/adapters/blockquote.js';
 
 import { handleAddedToSpace, handleRemovedFromSpace } from './subscriptions.js';
 import { handleCardClicked } from './cards.js';
@@ -52,13 +54,74 @@ export function getTRPCClient(options: { socketPath?: string } = {}) {
   });
 }
 
+export type GoogleChatApi = ReturnType<typeof google.chat>;
+
+interface QuotedSender {
+  type?: string | null;
+  email?: string | null;
+  name?: string | null;
+  displayName?: string | null;
+}
+
+/**
+ * Map a quoted message's sender to a short attribution label. Returns "Bot"
+ * for the assistant, "You" if it's one of the configured authorized users,
+ * and otherwise the sender's email (preferred) or `users/{id}` resource name.
+ */
+export function formatQuotedSender(
+  sender: QuotedSender | undefined,
+  authorizedUsers: string[]
+): string | undefined {
+  if (!sender) return undefined;
+  if (sender.type === 'BOT') return 'Assistant';
+  const email = sender.email ?? undefined;
+  const name = sender.name ?? undefined;
+  if (
+    (email && isAuthorized(email, authorizedUsers)) ||
+    (name && isAuthorized(name, authorizedUsers))
+  ) {
+    return undefined;
+  }
+  return email || sender.displayName || name || undefined;
+}
+
+export interface MessageSourceLike {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event: string, listener: (...args: any[]) => void | Promise<void>): unknown;
+}
+
+export interface GoogleChatIngestionDeps {
+  /** Inbound message source (defaults to a real Pub/Sub subscription). */
+  subscription?: MessageSourceLike;
+  /** Google Chat API client (defaults to `google.chat()` with ADC credentials). */
+  chatApi?: GoogleChatApi;
+  /** Root directory for resolving adapter state/config (defaults to `process.cwd()`). */
+  startDir?: string;
+  /** Attachment downloader (defaults to the real Chat media endpoint). */
+  downloadAttachment?: (resourceName: string, maxSizeMB?: number) => Promise<Buffer>;
+}
+
 export function startGoogleChatIngestion(
   config: GoogleChatConfig,
   trpc: ReturnType<typeof getTRPCClient>,
-  filteringConfig: FilteringConfig
+  filteringConfig: FilteringConfig,
+  deps: GoogleChatIngestionDeps = {}
 ) {
-  const pubsub = new PubSub({ projectId: config.projectId });
-  const subscription = pubsub.subscription(config.subscriptionName);
+  const startDir = deps.startDir ?? process.cwd();
+  const subscription: MessageSourceLike =
+    deps.subscription ??
+    (() => {
+      const pubsub = new PubSub({ projectId: config.projectId });
+      return pubsub.subscription(config.subscriptionName);
+    })();
+
+  const getChatApi = async (): Promise<GoogleChatApi> => {
+    if (deps.chatApi) return deps.chatApi;
+    const authClient = await getAuthClient();
+    return google.chat({ version: 'v1', auth: authClient });
+  };
+
+  const downloadAttachment = deps.downloadAttachment ?? defaultDownloadAttachment;
 
   const seenMessageIds = new Map<string, number>();
 
@@ -99,9 +162,13 @@ export function startGoogleChatIngestion(
         : parsedData.space || eventMessage?.space;
       const senderType = eventMessage?.sender?.type || '';
       const messageId = eventMessage?.name || '';
-      const text = (eventMessage?.argumentText || eventMessage?.text || '').trim();
+      const text = (eventMessage?.text || '').trim();
 
-      if (senderType === 'BOT') return void message.ack();
+      // CARD_CLICKED events carry the bot's original card message as
+      // `parsedData.message`, so `sender.type` is BOT even though the
+      // interaction was initiated by a real user (`parsedData.user`).
+      // Only drop BOT-authored MESSAGE events here.
+      if (senderType === 'BOT' && eventType !== 'CARD_CLICKED') return void message.ack();
 
       if (messageId) {
         if (seenMessageIds.has(messageId)) return void message.ack();
@@ -142,7 +209,7 @@ export function startGoogleChatIngestion(
           `Automatically authorizing user ID ${senderName} based on authorized email ${email}`
         );
         config.authorizedUsers.push(senderName);
-        updateGoogleChatConfig(config).catch((err) =>
+        updateGoogleChatConfig(config, startDir).catch((err) =>
           console.error('Failed to update config with new user ID:', err)
         );
       }
@@ -157,7 +224,7 @@ export function startGoogleChatIngestion(
         return;
       }
 
-      const currentState = await readGoogleChatState();
+      const currentState = await readGoogleChatState(startDir);
 
       const externalContextId = spaceName;
       const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
@@ -170,7 +237,8 @@ export function startGoogleChatIngestion(
           space?.type,
           mappedChatId,
           mappedChatId,
-          config
+          config,
+          startDir
         );
         if (!text) {
           message.ack();
@@ -179,7 +247,7 @@ export function startGoogleChatIngestion(
       }
 
       if (eventType === 'REMOVED_FROM_SPACE') {
-        await handleRemovedFromSpace(externalContextId, currentState, config);
+        await handleRemovedFromSpace(externalContextId, currentState, config, startDir);
         message.ack();
         return;
       }
@@ -198,20 +266,22 @@ export function startGoogleChatIngestion(
 
         if (routingResult) {
           if (routingResult.type === 'mapped') {
-            await updateGoogleChatState((latestState) => ({
-              channelChatMap: {
-                ...(latestState.channelChatMap || {}),
-                [externalContextId]: {
-                  ...(latestState.channelChatMap?.[externalContextId] || {}),
-                  chatId: routingResult.newChatId,
+            await updateGoogleChatState(
+              (latestState) => ({
+                channelChatMap: {
+                  ...(latestState.channelChatMap || {}),
+                  [externalContextId]: {
+                    ...(latestState.channelChatMap?.[externalContextId] || {}),
+                    chatId: routingResult.newChatId,
+                  },
                 },
-              },
-            }));
+              }),
+              startDir
+            );
           }
 
           try {
-            const authClient = await getAuthClient();
-            const chatApi = google.chat({ version: 'v1', auth: authClient });
+            const chatApi = await getChatApi();
             await chatApi.spaces.messages.create({
               parent: externalContextId,
               requestBody: { text: routingResult.text },
@@ -237,15 +307,18 @@ export function startGoogleChatIngestion(
           console.log(
             `First contact detected. Automatically mapping space ${externalContextId} to chat ${targetChatId}.`
           );
-          await updateGoogleChatState((latestState) => ({
-            channelChatMap: {
-              ...(latestState.channelChatMap || {}),
-              [externalContextId]: {
-                ...(latestState.channelChatMap?.[externalContextId] || {}),
-                chatId: targetChatId as string,
+          await updateGoogleChatState(
+            (latestState) => ({
+              channelChatMap: {
+                ...(latestState.channelChatMap || {}),
+                [externalContextId]: {
+                  ...(latestState.channelChatMap?.[externalContextId] || {}),
+                  chatId: targetChatId as string,
+                },
               },
-            },
-          }));
+            }),
+            startDir
+          );
         } else {
           const isDirectMessage =
             space?.type === 'DIRECT_MESSAGE' || space?.singleUserBotDm === true;
@@ -257,8 +330,7 @@ export function startGoogleChatIngestion(
           if (isDirectMessage || isMentioned || isSlashCommand) {
             console.log(`Unmapped space ${externalContextId}, sending first contact warning.`);
             try {
-              const authClient = await getAuthClient();
-              const chatApi = google.chat({ version: 'v1', auth: authClient });
+              const chatApi = await getChatApi();
               await chatApi.spaces.messages.create({
                 parent: externalContextId,
                 requestBody: {
@@ -300,8 +372,7 @@ export function startGoogleChatIngestion(
           let isReplyToBot = false;
           if (eventMessage?.threadReply && eventMessage.thread?.name) {
             try {
-              const authClient = await getAuthClient();
-              const chatApi = google.chat({ version: 'v1', auth: authClient });
+              const chatApi = await getChatApi();
               const response = await chatApi.spaces.messages.list({
                 parent: externalContextId,
                 filter: `thread.name="${eventMessage.thread.name}"`,
@@ -332,7 +403,8 @@ export function startGoogleChatIngestion(
         await handleCardClicked(
           parsedData,
           targetChatId as string,
-          trpc as unknown as RoutingTrpcClient
+          trpc as unknown as RoutingTrpcClient,
+          getChatApi
         );
         message.ack();
         return;
@@ -350,7 +422,7 @@ export function startGoogleChatIngestion(
         if (commandResult.type === 'text') {
           if (commandResult.newConfig) {
             filteringConfig.filters = commandResult.newConfig.filters;
-            await updateGoogleChatState({ filters: filteringConfig.filters });
+            await updateGoogleChatState({ filters: filteringConfig.filters }, startDir);
           }
           resultText = commandResult.text;
         } else if (commandResult.type === 'debug') {
@@ -361,8 +433,7 @@ export function startGoogleChatIngestion(
                 commandResult.messages.map((msg) => formatMessage(msg)).join('\n\n---\n\n');
         }
 
-        const authClient = await getAuthClient();
-        const chatApi = google.chat({ version: 'v1', auth: authClient });
+        const chatApi = await getChatApi();
         await chatApi.spaces.messages.create({
           parent: spaceName as string,
           requestBody: { text: resultText },
@@ -373,7 +444,7 @@ export function startGoogleChatIngestion(
       const attachments = eventMessage?.attachment || [];
 
       if (attachments.length > 0) {
-        const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'google-chat');
+        const tmpDir = path.join(getClawminiDir(startDir), 'tmp', 'google-chat');
         await fsPromises.mkdir(tmpDir, { recursive: true });
 
         for (const att of attachments) {
@@ -392,15 +463,44 @@ export function startGoogleChatIngestion(
         }
       }
 
+      let forwardedText = text;
+      const quotedMetadata = eventMessage?.quotedMessageMetadata;
+      if (quotedMetadata) {
+        let quotedText: string | undefined = quotedMetadata.quotedMessageSnapshot?.text;
+        let quotedSender: QuotedSender | undefined = quotedMetadata.quotedMessageSnapshot?.sender;
+        if ((!quotedText || !quotedSender) && quotedMetadata.name) {
+          try {
+            const chatApi = await getChatApi();
+            const quotedRes = await chatApi.spaces.messages.get({ name: quotedMetadata.name });
+            quotedText = quotedText || quotedRes.data?.text || undefined;
+            quotedSender =
+              quotedSender || (quotedRes.data?.sender as QuotedSender | undefined) || undefined;
+          } catch (err) {
+            console.error('Failed to fetch quoted message:', err);
+          }
+        }
+        if (quotedText) {
+          const senderLabel = formatQuotedSender(quotedSender, config.authorizedUsers);
+          forwardedText = prependBlockquote(quotedText, text, senderLabel);
+        }
+      }
+
+      const gchatThreadName: string | undefined =
+        eventMessage?.thread?.name ?? eventMessage?.threadName ?? undefined;
+      if (messageId && gchatThreadName) {
+        recordInbound({ gchatMessageName: messageId, gchatThreadName });
+      }
+
       await trpc.sendMessage.mutate({
         type: 'send-message',
         client: 'cli',
         data: {
-          message: text,
+          message: forwardedText,
           chatId: targetChatId,
           files: downloadedFiles.length > 0 ? downloadedFiles : undefined,
           adapter: 'google-chat',
           noWait: true,
+          ...(messageId ? { externalRef: messageId } : {}),
         },
       });
 

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

@@ -4,6 +4,24 @@ import { z } from 'zod';
 import { getClawminiDir } from '../shared/workspace.js';
 import fs from 'node:fs';
 
+export const ThreadVisibilitySchema = z.object({
+  threads: z.boolean().default(true).optional(),
+  threadLog: z
+    .object({
+      maxToolPreview: z.number().default(400).optional(),
+      maxLogMessageChars: z.number().default(3500).optional(),
+      editDebounceMs: z.number().default(1000).optional(),
+    })
+    .optional(),
+  // Proactive (cron) turns have no inbound user message. `silent` (default)
+  // drops the cron system message and anchors any thread-log activity on the
+  // agent's eventual top-level reply; if the agent never replies, nothing
+  // posts. `header` posts a terse `🕒 <jobId>` header top-level to serve as
+  // the anchor, making scheduled work visible even when the agent stays
+  // silent.
+  jobs: z.enum(['silent', 'header']).default('silent').optional(),
+});
+
 export const GoogleChatConfigSchema = z.looseObject({
   projectId: z.string().min(1, 'GCP Project ID is required.'),
   subscriptionName: z.string().min(1, 'Pub/Sub Subscription Name is required.'),
@@ -16,6 +34,7 @@ export const GoogleChatConfigSchema = z.looseObject({
   requireMention: z.boolean().default(false),
   oauthClientId: z.string().optional(),
   oauthClientSecret: z.string().optional(),
+  visibility: ThreadVisibilitySchema.optional(),
 });
 
 export type GoogleChatConfig = z.infer<typeof GoogleChatConfigSchema>;

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

@@ -1,6 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { startDaemonToGoogleChatForwarder } from './forwarder.js';
 
+// `waitForMessages` yields `ChatStreamItem` envelopes (discriminated by
+// `kind`). Tests send raw message shapes; wrap them here.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const asEnvelopes = (messages: any[]) => messages.map((message) => ({ kind: 'message', message }));
+
 const mockConfig = {
   projectId: 'test',
   subscriptionName: 'test',
@@ -77,7 +82,7 @@ vi.mock('./state.js', () => ({
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   updateGoogleChatState: (updates: any) => {
     const currentState = { lastSyncedMessageIds: { otherChat: 'msg-other' } };
-    const result = typeof updates === 'function' ? updates(currentState as any) : updates;
+    const result = typeof updates === 'function' ? updates(currentState) : updates;
     mockStateDeps.mockWriteState(result);
     return Promise.resolve(result);
   },
@@ -158,14 +163,16 @@ describe('Daemon to Google Chat Forwarder', () => {
       expect.any(Object)
     );
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-2',
-        role: 'agent',
-        content: 'Agent response',
-        timestamp: '',
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-2',
+          role: 'agent',
+          content: 'Agent response',
+          timestamp: '',
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalled());
 
@@ -190,14 +197,16 @@ describe('Daemon to Google Chat Forwarder', () => {
 
     await vi.waitFor(() => expect(subscribeCallbacks).toBeTruthy());
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-2',
-        role: 'agent',
-        content: 'Here are the files',
-        files: ['/tmp/file1.png', '/tmp/file2.txt'],
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-2',
+          role: 'agent',
+          content: 'Here are the files',
+          files: ['/tmp/file1.png', '/tmp/file2.txt'],
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalled());
 
@@ -232,14 +241,16 @@ describe('Daemon to Google Chat Forwarder', () => {
 
     await vi.waitFor(() => expect(subscribeCallbacks).toBeTruthy());
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-3',
-        role: 'agent',
-        content: 'Here are the files',
-        files: ['/tmp/file1.png', '/tmp/file2.txt'],
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-3',
+          role: 'agent',
+          content: 'Here are the files',
+          files: ['/tmp/file1.png', '/tmp/file2.txt'],
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalled());
 
@@ -270,14 +281,16 @@ describe('Daemon to Google Chat Forwarder', () => {
 
     mockDriveFilesCreate.mockRejectedValueOnce(new Error('Drive Auth Failed'));
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-drive-fail',
-        role: 'agent',
-        content: 'Here are the files',
-        files: ['/tmp/file1.png'],
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-drive-fail',
+          role: 'agent',
+          content: 'Here are the files',
+          files: ['/tmp/file1.png'],
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalled());
 
@@ -313,10 +326,12 @@ describe('Daemon to Google Chat Forwarder', () => {
       return Promise.resolve();
     });
 
-    subscribeCallbacks.onData([
-      { id: 'msg-err-1', role: 'agent', content: 'Agent response 1' },
-      { id: 'msg-err-2', role: 'agent', content: 'Agent response 2' },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        { id: 'msg-err-1', role: 'agent', content: 'Agent response 1' },
+        { id: 'msg-err-2', role: 'agent', content: 'Agent response 2' },
+      ])
+    );
 
     // Wait for the second message to be processed, meaning the first one didn't break the loop
     await vi.waitFor(() => expect(callCount).toBe(2));
@@ -348,14 +363,16 @@ describe('Daemon to Google Chat Forwarder', () => {
 
     await vi.waitFor(() => expect(subscribeCallbacks).toBeTruthy());
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-2',
-        role: 'policy',
-        status: 'pending',
-        content: 'Please approve this action',
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-2',
+          role: 'policy',
+          status: 'pending',
+          content: 'Please approve this action',
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalled());
 
@@ -434,14 +451,16 @@ describe('Daemon to Google Chat Forwarder', () => {
       .mockRejectedValueOnce(new Error('Cannot send cardsV2'))
       .mockResolvedValueOnce({});
 
-    subscribeCallbacks.onData([
-      {
-        id: 'msg-2',
-        role: 'policy',
-        status: 'pending',
-        content: 'Please approve this action',
-      },
-    ]);
+    subscribeCallbacks.onData(
+      asEnvelopes([
+        {
+          id: 'msg-2',
+          role: 'policy',
+          status: 'pending',
+          content: 'Please approve this action',
+        },
+      ])
+    );
 
     await vi.waitFor(() => expect(mockMessagesCreate).toHaveBeenCalledTimes(2));
 
@@ -473,7 +492,9 @@ describe('Daemon to Google Chat Forwarder', () => {
     await vi.waitFor(() => expect(subscribeCallbacks).toBeTruthy(), { timeout: 1000 });
 
     // Send a message, this updates the local memory cache to msg-local
-    subscribeCallbacks.onData([{ id: 'msg-local', role: 'agent', content: 'Agent response' }]);
+    subscribeCallbacks.onData(
+      asEnvelopes([{ id: 'msg-local', role: 'agent', content: 'Agent response' }])
+    );
 
     await vi.waitFor(
       () =>
@@ -500,7 +521,9 @@ describe('Daemon to Google Chat Forwarder', () => {
     await vi.runAllTicks();
 
     // Send another message to verify what the local cache holds
-    subscribeCallbacks.onData([{ id: 'msg-latest', role: 'agent', content: 'Agent response 2' }]);
+    subscribeCallbacks.onData(
+      asEnvelopes([{ id: 'msg-latest', role: 'agent', content: 'Agent response 2' }])
+    );
 
     // If local memory wins, the new write state will only contain msg-latest and not msg-stale
     // If disk won, it would have reverted to msg-stale and then updated to msg-latest?
@@ -515,7 +538,9 @@ describe('Daemon to Google Chat Forwarder', () => {
 
     await vi.advanceTimersByTimeAsync(6000);
 
-    subscribeCallbacks.onData([{ id: 'msg-latest', role: 'agent', content: 'Agent response 2' }]);
+    subscribeCallbacks.onData(
+      asEnvelopes([{ id: 'msg-latest', role: 'agent', content: 'Agent response 2' }])
+    );
 
     await vi.waitFor(
       () =>