clawmini 0.0.3 → 0.0.5

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

@@ -0,0 +1,349 @@
+/* eslint-disable max-lines */
+import { google } from 'googleapis';
+import { getAuthClient } from './auth.js';
+import type { getTRPCClient } from './client.js';
+import type { ChatMessage } from '../shared/chats.js';
+import path from 'node:path';
+import fs from 'node:fs';
+import type { GoogleChatConfig } from './config.js';
+import { readGoogleChatState, updateGoogleChatState, getGoogleChatStatePath } from './state.js';
+import {
+  shouldDisplayMessage,
+  formatMessage,
+  type FilteringConfig,
+} from '../shared/adapters/filtering.js';
+import { buildPolicyCard, chunkString } from './utils.js';
+import { uploadFilesToDrive } from './upload.js';
+
+export async function startDaemonToGoogleChatForwarder(
+  trpc: ReturnType<typeof getTRPCClient>,
+  config: GoogleChatConfig,
+  filteringConfig: FilteringConfig,
+  signal?: AbortSignal
+) {
+  const defaultChatId = config.chatId || 'default';
+
+  const activeSubscriptions = new Map<string, { unsubscribe: () => void }>();
+  let currentLastSyncedMessageIds = (await readGoogleChatState()).lastSyncedMessageIds || {};
+
+  const saveLastMessageId = async (chatId: string, id: string) => {
+    currentLastSyncedMessageIds = { ...currentLastSyncedMessageIds, [chatId]: id };
+    return updateGoogleChatState((state) => ({
+      lastSyncedMessageIds: {
+        ...state.lastSyncedMessageIds,
+        ...currentLastSyncedMessageIds,
+      },
+    }));
+  };
+
+  const startSubscriptionForChat = async (chatId: string) => {
+    if (activeSubscriptions.has(chatId)) return;
+    if (signal?.aborted) return;
+
+    let lastMessageId = currentLastSyncedMessageIds[chatId];
+
+    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) {
+            await saveLastMessageId(chatId, lastMsg.id);
+            lastMessageId = lastMsg.id;
+          }
+        }
+      } catch (error) {
+        if (signal?.aborted) return;
+        console.error(`Failed to fetch initial messages from daemon for ${chatId}:`, error);
+      }
+    }
+
+    console.log(
+      `Starting daemon-to-google-chat forwarder for chat ${chatId}, lastMessageId: ${lastMessageId}`
+    );
+
+    let retryDelay = 1000;
+    const maxRetryDelay = 30000;
+
+    let subscription: { unsubscribe: () => void } | null = null;
+    let messageQueue = Promise.resolve();
+
+    const connect = () => {
+      if (signal?.aborted || !activeSubscriptions.has(chatId)) {
+        return;
+      }
+
+      subscription = trpc.waitForMessages.subscribe(
+        { chatId, lastMessageId },
+        {
+          onData: (messages) => {
+            retryDelay = 1000;
+
+            if (!Array.isArray(messages) || messages.length === 0) {
+              return;
+            }
+
+            messageQueue = messageQueue
+              .then(async () => {
+                for (const rawMessage of messages) {
+                  if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
+
+                  const message = rawMessage as ChatMessage;
+
+                  const isDisplayed = shouldDisplayMessage(message, filteringConfig);
+
+                  if (isDisplayed) {
+                    const logMessage = message;
+
+                    const currentState = await readGoogleChatState();
+                    let activeSpaceName: string | undefined;
+
+                    if (!activeSpaceName && currentState.channelChatMap) {
+                      const entry = Object.entries(currentState.channelChatMap).find(
+                        ([_, mapChatId]) => mapChatId?.chatId === chatId
+                      );
+                      if (entry) {
+                        activeSpaceName = entry[0];
+                      }
+                    }
+
+                    // We no longer fallback to config.directMessageName. If it's not mapped, we'll drop it below.
+
+                    const isPolicyRequest =
+                      logMessage.role === 'policy' && logMessage.status === 'pending';
+
+                    if (isPolicyRequest) {
+                      if (!activeSpaceName) {
+                        console.warn(
+                          'No active Google Chat space to reply to. Ignoring policy request:',
+                          logMessage.content
+                        );
+                        await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+                        lastMessageId = logMessage.id;
+                        continue;
+                      }
+
+                      try {
+                        const client = await getAuthClient();
+                        const chatApi = google.chat({ version: 'v1', auth: client });
+
+                        try {
+                          await chatApi.spaces.messages.create({
+                            parent: activeSpaceName as string,
+                            requestBody: {
+                              text: '',
+                              cardsV2: buildPolicyCard(logMessage),
+                            },
+                          });
+                        } catch (richError) {
+                          console.warn(
+                            'Failed to send rich policy request to Google Chat, falling back to plain text:',
+                            richError
+                          );
+                          const policyId =
+                            ('requestId' in logMessage && logMessage.requestId) || logMessage.id;
+                          await chatApi.spaces.messages.create({
+                            parent: activeSpaceName as string,
+                            requestBody: {
+                              text: `Action Required: Policy Request\n\n${logMessage.content || 'A pending policy request requires your attention.'}\n\nApprove: \`/approve ${policyId}\`\nReject: \`/reject ${policyId} <optional_rationale>\``,
+                            },
+                          });
+                        }
+                      } catch (error) {
+                        console.error('Failed to send policy request to Google Chat:', error);
+                      }
+
+                      await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+                      lastMessageId = logMessage.id;
+                      continue;
+                    }
+
+                    const hasContent = !!logMessage.content?.trim();
+                    const files =
+                      'files' in logMessage ? (logMessage.files as string[]) : undefined;
+                    const hasFiles = Array.isArray(files) && files.length > 0;
+
+                    if (
+                      ('level' in logMessage && logMessage.level === 'verbose') ||
+                      (!hasContent && !hasFiles)
+                    ) {
+                      await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+                      lastMessageId = logMessage.id;
+                      continue;
+                    }
+
+                    if (!activeSpaceName) {
+                      console.warn(
+                        'No active Google Chat space to reply to. Ignoring message:',
+                        logMessage.content
+                      );
+                      await saveLastMessageId(chatId, logMessage.id).catch(console.error);
+                      lastMessageId = logMessage.id;
+                      continue;
+                    }
+
+                    try {
+                      const client = await getAuthClient();
+                      const chatApi = google.chat({ version: 'v1', auth: client });
+
+                      let text = formatMessage(logMessage) || '';
+
+                      if (hasFiles && files) {
+                        const fileNames = files.map((f) => path.basename(f)).join(', ');
+
+                        if (
+                          config.driveUploadEnabled !== false &&
+                          config.oauthClientId &&
+                          config.oauthClientSecret
+                        ) {
+                          text += `\n\n`;
+                          try {
+                            const uploadResults = await uploadFilesToDrive(files, config);
+                            for (const result of uploadResults) {
+                              text += `${result}\n`;
+                            }
+                          } catch (driveAuthErr) {
+                            console.error(
+                              'Drive API/Auth Failed, degrading to local files output:',
+                              driveAuthErr
+                            );
+                            text += `*(Files generated: ${fileNames})*`;
+                          }
+                        } else {
+                          text += `\n\n*(Files generated: ${fileNames})*`;
+                        }
+                      }
+
+                      if (text.length > 4000) {
+                        const chunks = chunkString(text, 4000);
+                        for (let i = 0; i < chunks.length; i++) {
+                          if (signal?.aborted || !activeSubscriptions.has(chatId)) break;
+                          await chatApi.spaces.messages.create({
+                            parent: activeSpaceName as string,
+                            requestBody: { text: chunks[i] as string },
+                          });
+                        }
+                      } else {
+                        await chatApi.spaces.messages.create({
+                          parent: activeSpaceName as string,
+                          requestBody: { text },
+                        });
+                      }
+                    } catch (error) {
+                      console.error('Failed to send message to Google Chat:', error);
+                    }
+                  }
+
+                  await saveLastMessageId(chatId, message.id).catch(console.error);
+                  lastMessageId = message.id;
+                }
+              })
+              .catch((error) => {
+                console.error('Message queue failed, forcing reconnect...', error);
+                subscription?.unsubscribe();
+                subscription = null;
+                if (signal?.aborted || !activeSubscriptions.has(chatId)) {
+                  return;
+                }
+                setTimeout(() => {
+                  retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+                  connect();
+                }, retryDelay);
+              });
+          },
+          onError: (error) => {
+            console.error(
+              `Error in daemon-to-google-chat forwarder subscription for ${chatId}. Retrying in ${retryDelay}ms.`,
+              error
+            );
+            subscription?.unsubscribe();
+            subscription = null;
+
+            if (signal?.aborted || !activeSubscriptions.has(chatId)) {
+              return;
+            }
+
+            setTimeout(() => {
+              retryDelay = Math.min(retryDelay * 2, maxRetryDelay);
+              connect();
+            }, retryDelay);
+          },
+          onComplete: () => {
+            subscription = null;
+            if (!signal?.aborted && activeSubscriptions.has(chatId)) {
+              setTimeout(() => connect(), retryDelay);
+            }
+          },
+        }
+      );
+    };
+
+    activeSubscriptions.set(chatId, {
+      unsubscribe: () => subscription?.unsubscribe(),
+    });
+
+    connect();
+  };
+
+  const syncSubscriptions = async () => {
+    if (signal?.aborted) return;
+    const state = await readGoogleChatState();
+
+    // Update local copy of last message IDs
+    if (state.lastSyncedMessageIds) {
+      currentLastSyncedMessageIds = {
+        ...state.lastSyncedMessageIds,
+        ...currentLastSyncedMessageIds,
+      };
+    }
+
+    const targetChatIds = new Set<string>();
+    targetChatIds.add(defaultChatId);
+
+    if (state.channelChatMap) {
+      for (const mappedEntry of Object.values(state.channelChatMap)) {
+        if (mappedEntry.chatId) {
+          targetChatIds.add(mappedEntry.chatId);
+        }
+      }
+    }
+
+    for (const targetChatId of targetChatIds) {
+      if (!activeSubscriptions.has(targetChatId)) {
+        startSubscriptionForChat(targetChatId);
+      }
+    }
+
+    for (const [activeChatId, sub] of activeSubscriptions.entries()) {
+      if (!targetChatIds.has(activeChatId)) {
+        sub.unsubscribe();
+        activeSubscriptions.delete(activeChatId);
+      }
+    }
+  };
+  return new Promise<void>((resolve) => {
+    syncSubscriptions().catch(console.error);
+
+    const statePath = getGoogleChatStatePath();
+    const stateDir = path.dirname(statePath);
+    if (!fs.existsSync(stateDir)) {
+      fs.mkdirSync(stateDir, { recursive: true });
+    }
+    let debounceTimer: NodeJS.Timeout | null = null;
+    const watcher = fs.watch(stateDir, (eventType, filename) => {
+      if (filename === path.basename(statePath)) {
+        if (debounceTimer) clearTimeout(debounceTimer);
+        debounceTimer = setTimeout(() => {
+          syncSubscriptions().catch(console.error);
+        }, 200);
+      }
+    });
+
+    signal?.addEventListener('abort', () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      watcher.close();
+      for (const sub of activeSubscriptions.values()) sub.unsubscribe();
+      resolve();
+    });
+  });
+}

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

@@ -0,0 +1,62 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { main } from './index.js';
+import * as config from './config.js';
+import * as client from './client.js';
+import * as forwarder from './forwarder.js';
+
+vi.mock('./config.js', () => ({
+  initGoogleChatConfig: vi.fn(),
+  readGoogleChatConfig: vi.fn(),
+}));
+
+vi.mock('./client.js', () => ({
+  getTRPCClient: vi.fn().mockReturnValue({}),
+  startGoogleChatIngestion: vi.fn(),
+}));
+
+vi.mock('./forwarder.js', () => ({
+  startDaemonToGoogleChatForwarder: vi.fn().mockResolvedValue(undefined),
+}));
+
+describe('Google Chat Adapter Entry Point', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should initialize config and exit if init argument is provided', async () => {
+    process.argv = ['node', 'index.js', 'init'];
+    await main();
+    expect(config.initGoogleChatConfig).toHaveBeenCalled();
+    expect(config.readGoogleChatConfig).not.toHaveBeenCalled();
+    process.argv = []; // reset
+  });
+
+  it('should start ingestion and forwarder with valid config', async () => {
+    process.argv = ['node', 'index.js'];
+    const mockConfig = {
+      projectId: 'test-project',
+      subscriptionName: 'test-sub',
+      topicName: 'test-topic',
+      authorizedUsers: ['test@example.com'],
+      requireMention: false,
+      chatId: 'default',
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    vi.mocked(config.readGoogleChatConfig).mockResolvedValue(mockConfig as any);
+
+    await main();
+
+    expect(config.readGoogleChatConfig).toHaveBeenCalled();
+    expect(client.getTRPCClient).toHaveBeenCalled();
+    expect(client.startGoogleChatIngestion).toHaveBeenCalledWith(
+      mockConfig,
+      expect.any(Object),
+      {}
+    );
+    expect(forwarder.startDaemonToGoogleChatForwarder).toHaveBeenCalledWith(
+      expect.any(Object),
+      mockConfig,
+      {}
+    );
+  });
+});

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

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { initGoogleChatConfig, readGoogleChatConfig } from './config.js';
+import { readGoogleChatState } from './state.js';
+import { getTRPCClient, startGoogleChatIngestion } from './client.js';
+import { startDaemonToGoogleChatForwarder } from './forwarder.js';
+import { getUserAuthClient } from './auth.js';
+import { startSubscriptionRenewalCron } from './cron.js';
+import type { FilteringConfig } from '../shared/adapters/filtering.js';
+
+export async function main() {
+  const args = process.argv.slice(2);
+
+  if (args[0] === 'init') {
+    await initGoogleChatConfig();
+    return;
+  }
+
+  console.log('Google Chat Adapter starting...');
+
+  const config = await readGoogleChatConfig();
+  if (!config) {
+    console.error(
+      'Failed to load Google Chat configuration. Please ensure .clawmini/adapters/google-chat/config.json exists and is valid.'
+    );
+    process.exit(1);
+  }
+
+  if (config.oauthClientId && config.oauthClientSecret) {
+    try {
+      console.log('Initializing Google User Authentication...');
+      await getUserAuthClient(config);
+    } catch (err) {
+      console.error('Failed to initialize Google User authentication:', err);
+      process.exit(1);
+    }
+  }
+
+  const trpc = getTRPCClient();
+  const state = await readGoogleChatState();
+  const filteringConfig: FilteringConfig = { filters: state.filters };
+
+  // Start ingestion from Pub/Sub
+  startGoogleChatIngestion(config, trpc, filteringConfig);
+  console.log(`Listening to Pub/Sub subscription: ${config.subscriptionName}`);
+
+  // Start forwarding from daemon to Google Chat API
+  startDaemonToGoogleChatForwarder(trpc, config, filteringConfig).catch((error) => {
+    console.error('Error in daemon-to-google-chat forwarder:', error);
+  });
+
+  // Start background cron for renewing Space Subscriptions
+  startSubscriptionRenewalCron(config);
+}
+
+if (process.env.NODE_ENV !== 'test') {
+  main().catch((error) => {
+    console.error('Unhandled error in Google Chat Adapter:', error);
+    process.exit(1);
+  });
+}

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

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { updateGoogleChatState } from './state.js';
+import fsPromises from 'node:fs/promises';
+
+vi.mock('node:fs/promises', () => ({
+  default: {
+    readFile: vi.fn(),
+    writeFile: vi.fn(),
+    mkdir: vi.fn(),
+  },
+}));
+
+vi.mock('../shared/workspace.js', () => ({
+  getClawminiDir: () => '/mock/clawmini',
+}));
+
+describe('Google Chat State Updates', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should process concurrent state updates sequentially to prevent data loss', async () => {
+    // Create an initial state where lastSyncedMessageIds is 'A' and oauthTokens is 'Space1'
+    const initialState = { lastSyncedMessageId: 'A', oauthTokens: 'Space1' };
+
+    // We mock readFile to always return the LAST state that was written by writeFile.
+    // However, if the read/writes were not sequential (if they ran truly concurrently without a mutex),
+    // they might both read the initial state and then overwrite each other.
+
+    let currentMockStateJSON = JSON.stringify(initialState);
+
+    vi.mocked(fsPromises.readFile).mockImplementation(async () => {
+      // simulate delay to maximize chance of race condition if no mutex is used
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return currentMockStateJSON;
+    });
+
+    vi.mocked(fsPromises.writeFile).mockImplementation(async (_path, data) => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      currentMockStateJSON = data as string;
+    });
+
+    // Fire two concurrent updates
+    const update1 = updateGoogleChatState({ lastSyncedMessageIds: { default: 'B' } });
+    const update2 = updateGoogleChatState({ oauthTokens: 'Space2' });
+
+    await Promise.all([update1, update2]);
+
+    // Read the final state
+    const finalState = JSON.parse(currentMockStateJSON);
+
+    // If a race condition occurred, finalState would likely be either:
+    // { lastSyncedMessageId: 'B', oauthTokens: 'Space1' } OR
+    // { lastSyncedMessageId: 'A', oauthTokens: 'Space2' }
+    // Because they are serialized, it should safely contain BOTH updates.
+    expect(finalState).toEqual({
+      lastSyncedMessageIds: { default: 'B' },
+      oauthTokens: 'Space2',
+    });
+  });
+
+  it('should process callback updates sequentially and receive latest state', async () => {
+    const initialState = { channelChatMap: { 'ext-1': { chatId: 'chat-1' } } };
+    let currentMockStateJSON = JSON.stringify(initialState);
+
+    vi.mocked(fsPromises.readFile).mockImplementation(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      return currentMockStateJSON;
+    });
+
+    vi.mocked(fsPromises.writeFile).mockImplementation(async (_path, data) => {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+      currentMockStateJSON = data as string;
+    });
+
+    // Fire two concurrent callback updates
+    const update1 = updateGoogleChatState((latest) => ({
+      channelChatMap: { ...latest.channelChatMap, 'ext-2': { chatId: 'chat-2' } },
+    }));
+    const update2 = updateGoogleChatState((latest) => ({
+      channelChatMap: { ...latest.channelChatMap, 'ext-3': { chatId: 'chat-3' } },
+    }));
+
+    await Promise.all([update1, update2]);
+
+    const finalState = JSON.parse(currentMockStateJSON);
+
+    expect(finalState).toEqual({
+      channelChatMap: {
+        'ext-1': { chatId: 'chat-1' },
+        'ext-2': { chatId: 'chat-2' },
+        'ext-3': { chatId: 'chat-3' },
+      },
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { getClawminiDir } from '../shared/workspace.js';
+
+export const GoogleChatStateSchema = z.object({
+  lastSyncedMessageIds: z.record(z.string(), z.string()).optional(),
+  channelChatMap: z
+    .record(
+      z.string(),
+      z.object({
+        chatId: z.string().nullable().optional(),
+        subscriptionId: z.string().optional(),
+        expirationDate: z.string().optional(),
+        requireMention: z.boolean().optional(),
+      })
+    )
+    .optional(),
+  oauthTokens: z.any().optional(),
+  filters: z.record(z.string(), z.boolean()).optional(),
+});
+
+export type GoogleChatState = z.infer<typeof GoogleChatStateSchema>;
+
+export function getGoogleChatStatePath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'adapters', 'google-chat', 'state.json');
+}
+
+export async function readGoogleChatState(startDir = process.cwd()): Promise<GoogleChatState> {
+  const statePath = getGoogleChatStatePath(startDir);
+  try {
+    const data = await fsPromises.readFile(statePath, 'utf-8');
+    const parsed = JSON.parse(data);
+
+    // Migrate legacy state
+    if (parsed.lastSyncedMessageId && !parsed.lastSyncedMessageIds) {
+      parsed.lastSyncedMessageIds = { default: parsed.lastSyncedMessageId };
+    }
+    if (parsed.driveOauthTokens && !parsed.oauthTokens) {
+      parsed.oauthTokens = parsed.driveOauthTokens;
+      delete parsed.driveOauthTokens;
+    }
+    if (parsed.channelChatMap) {
+      for (const [key, value] of Object.entries(parsed.channelChatMap)) {
+        if (typeof value === 'string') {
+          parsed.channelChatMap[key] = { chatId: value };
+        }
+      }
+    }
+
+    return GoogleChatStateSchema.parse(parsed);
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return {
+        oauthTokens: undefined,
+      };
+    }
+    throw err;
+  }
+}
+
+let stateUpdatePromise = Promise.resolve();
+
+export function updateGoogleChatState(
+  updates: Partial<GoogleChatState> | ((state: GoogleChatState) => Partial<GoogleChatState>),
+  startDir = process.cwd()
+): Promise<GoogleChatState> {
+  return new Promise((resolve, reject) => {
+    stateUpdatePromise = stateUpdatePromise.then(async () => {
+      try {
+        const currentState = await readGoogleChatState(startDir);
+        const resolvedUpdates = typeof updates === 'function' ? updates(currentState) : updates;
+        const newState = { ...currentState, ...resolvedUpdates };
+        const statePath = getGoogleChatStatePath(startDir);
+        const dir = path.dirname(statePath);
+        await fsPromises.mkdir(dir, { recursive: true });
+        await fsPromises.writeFile(statePath, JSON.stringify(newState, null, 2), 'utf-8');
+        resolve(newState);
+      } catch (err) {
+        console.error(`Failed to write Google Chat state:`, err);
+        reject(err);
+      }
+    });
+  });
+}