clawmini 0.0.3 → 0.0.5

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

@@ -0,0 +1,430 @@
+/* eslint-disable max-lines */
+import { PubSub, Message } from '@google-cloud/pubsub';
+import { createTRPCClient, httpLink, splitLink, httpSubscriptionLink } from '@trpc/client';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import crypto from 'node:crypto';
+
+import type { UserRouter as AppRouter } from '../daemon/api/index.js';
+import { getSocketPath, getClawminiDir } from '../shared/workspace.js';
+import { createUnixSocketFetch } from '../shared/fetch.js';
+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 { 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 { handleAddedToSpace, handleRemovedFromSpace } from './subscriptions.js';
+import { handleCardClicked } from './cards.js';
+
+export function getTRPCClient(options: { socketPath?: string } = {}) {
+  const socketPath = options.socketPath ?? getSocketPath();
+
+  if (!fs.existsSync(socketPath)) {
+    throw new Error(`Daemon not running. Socket not found at ${socketPath}`);
+  }
+
+  const customFetch = createUnixSocketFetch(socketPath);
+  const CustomEventSource = createUnixSocketEventSource(socketPath);
+
+  return createTRPCClient<AppRouter>({
+    links: [
+      splitLink({
+        condition(op) {
+          return op.type === 'subscription';
+        },
+        true: httpSubscriptionLink({
+          url: 'http://localhost',
+          EventSource: CustomEventSource,
+        }),
+        false: httpLink({
+          url: 'http://localhost',
+          fetch: customFetch,
+        }),
+      }),
+    ],
+  });
+}
+
+export function startGoogleChatIngestion(
+  config: GoogleChatConfig,
+  trpc: ReturnType<typeof getTRPCClient>,
+  filteringConfig: FilteringConfig
+) {
+  const pubsub = new PubSub({ projectId: config.projectId });
+  const subscription = pubsub.subscription(config.subscriptionName);
+
+  const seenMessageIds = new Map<string, number>();
+
+  // Periodically clean up deduplication cache every 5 minutes
+  setInterval(
+    () => {
+      const now = Date.now();
+      for (const [id, ts] of seenMessageIds.entries()) {
+        if (now - ts > 10 * 60 * 1000) {
+          seenMessageIds.delete(id);
+        }
+      }
+    },
+    5 * 60 * 1000
+  ).unref();
+
+  subscription.on('message', async (message: Message) => {
+    const downloadedFiles: string[] = [];
+    try {
+      const dataString = message.data.toString('utf8');
+      const parsedData = JSON.parse(dataString);
+
+      const isWorkspaceEvent =
+        message.attributes &&
+        message.attributes['ce-type'] === 'google.workspace.chat.message.v1.created';
+
+      const eventType = isWorkspaceEvent ? 'MESSAGE' : parsedData.type;
+
+      const eventMessage = isWorkspaceEvent ? parsedData.message || parsedData : parsedData.message;
+      const email =
+        (isWorkspaceEvent
+          ? eventMessage?.sender?.email
+          : parsedData.user?.email || eventMessage?.sender?.email) || '';
+      const senderName = eventMessage?.sender?.name || parsedData.user?.name || '';
+
+      const space = isWorkspaceEvent
+        ? eventMessage?.space
+        : parsedData.space || eventMessage?.space;
+      const senderType = eventMessage?.sender?.type || '';
+      const messageId = eventMessage?.name || '';
+      const text = (eventMessage?.argumentText || eventMessage?.text || '').trim();
+
+      if (senderType === 'BOT') return void message.ack();
+
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) return void message.ack();
+        seenMessageIds.set(messageId, Date.now());
+      }
+
+      // Only handle MESSAGE, CARD_CLICKED, ADDED_TO_SPACE, and REMOVED_FROM_SPACE events
+      if (
+        eventType !== 'MESSAGE' &&
+        eventType !== 'CARD_CLICKED' &&
+        eventType !== 'ADDED_TO_SPACE' &&
+        eventType !== 'REMOVED_FROM_SPACE'
+      ) {
+        message.ack();
+        return;
+      }
+
+      let isUserAuthorized = false;
+      let authorizedByEmail = false;
+
+      if (email && isAuthorized(email, config.authorizedUsers)) {
+        isUserAuthorized = true;
+        authorizedByEmail = true;
+      } else if (senderName && isAuthorized(senderName, config.authorizedUsers)) {
+        isUserAuthorized = true;
+      }
+
+      if (!isUserAuthorized) {
+        console.log(`Unauthorized or missing identifier: email=${email}, name=${senderName}`);
+        console.log('DEBUG missing identifier parsedData:', JSON.stringify(parsedData, null, 2));
+        message.ack();
+        return;
+      }
+
+      // Automatically authorize user IDs if associated an authorized email
+      if (authorizedByEmail && senderName && !isAuthorized(senderName, config.authorizedUsers)) {
+        console.log(
+          `Automatically authorizing user ID ${senderName} based on authorized email ${email}`
+        );
+        config.authorizedUsers.push(senderName);
+        updateGoogleChatConfig(config).catch((err) =>
+          console.error('Failed to update config with new user ID:', err)
+        );
+      }
+
+      const identifier = email || senderName;
+
+      const spaceName = space?.name;
+
+      if (!spaceName) {
+        console.log('Ignoring message: Could not determine space name.');
+        message.ack();
+        return;
+      }
+
+      const currentState = await readGoogleChatState();
+
+      const externalContextId = spaceName;
+      const mappedChatId = currentState.channelChatMap?.[externalContextId]?.chatId;
+      const isRoutingCommand = text.startsWith('/chat') || text.startsWith('/agent');
+
+      if (eventType === 'ADDED_TO_SPACE') {
+        await handleAddedToSpace(
+          spaceName as string,
+          externalContextId,
+          space?.type,
+          mappedChatId,
+          mappedChatId,
+          config
+        );
+        if (!text) {
+          message.ack();
+          return;
+        }
+      }
+
+      if (eventType === 'REMOVED_FROM_SPACE') {
+        await handleRemovedFromSpace(externalContextId, currentState, config);
+        message.ack();
+        return;
+      }
+
+      if (isRoutingCommand) {
+        const stringChatMap = Object.fromEntries(
+          Object.entries(currentState.channelChatMap || {}).map(([k, v]) => [k, v.chatId || ''])
+        );
+        const routingResult = await handleRoutingCommand(
+          text,
+          externalContextId,
+          stringChatMap,
+          'google-chat',
+          trpc as unknown as RoutingTrpcClient
+        );
+
+        if (routingResult) {
+          if (routingResult.type === 'mapped') {
+            await updateGoogleChatState((latestState) => ({
+              channelChatMap: {
+                ...(latestState.channelChatMap || {}),
+                [externalContextId]: {
+                  ...(latestState.channelChatMap?.[externalContextId] || {}),
+                  chatId: routingResult.newChatId,
+                },
+              },
+            }));
+          }
+
+          try {
+            const authClient = await getAuthClient();
+            const chatApi = google.chat({ version: 'v1', auth: authClient });
+            await chatApi.spaces.messages.create({
+              parent: externalContextId,
+              requestBody: { text: routingResult.text },
+            });
+          } catch (err) {
+            console.error('Failed to send routing command reply:', err);
+          }
+
+          message.ack();
+          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 space ${externalContextId} to chat ${targetChatId}.`
+          );
+          await updateGoogleChatState((latestState) => ({
+            channelChatMap: {
+              ...(latestState.channelChatMap || {}),
+              [externalContextId]: {
+                ...(latestState.channelChatMap?.[externalContextId] || {}),
+                chatId: targetChatId as string,
+              },
+            },
+          }));
+        } else {
+          const isDirectMessage =
+            space?.type === 'DIRECT_MESSAGE' || space?.singleUserBotDm === true;
+          const isMentioned =
+            Array.isArray(eventMessage?.annotations) &&
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            eventMessage.annotations.some((a: any) => a.type === 'USER_MENTION');
+          const isSlashCommand = text.startsWith('/');
+          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 });
+              await chatApi.spaces.messages.create({
+                parent: externalContextId,
+                requestBody: {
+                  text: 'This channel/space is not currently mapped to a daemon chat. Please use `/chat [chat-id]` or `/agent [agent-id]` to map it.',
+                },
+              });
+            } catch (err) {
+              console.error('Failed to send first contact warning:', err);
+            }
+          } else {
+            console.log(
+              `Unmapped space ${externalContextId}, silently ignoring background message.`
+            );
+          }
+          message.ack();
+          return;
+        }
+      }
+
+      // Fallback typing safeguard
+      if (!targetChatId) targetChatId = config.chatId || 'default';
+
+      const isDirectMessage = space?.type === 'DIRECT_MESSAGE' || space?.singleUserBotDm === true;
+      if (!isDirectMessage && eventType === 'MESSAGE') {
+        const channelConfig = currentState.channelChatMap?.[externalContextId];
+        const requiresMention =
+          channelConfig?.requireMention !== undefined
+            ? channelConfig.requireMention
+            : config.requireMention;
+
+        if (requiresMention && !isRoutingCommand) {
+          const isMentioned =
+            Array.isArray(eventMessage?.annotations) &&
+            eventMessage.annotations.some(
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              (a: any) => a.type === 'USER_MENTION' && a.userMention?.user?.type === 'BOT'
+            );
+
+          let isReplyToBot = false;
+          if (eventMessage?.threadReply && eventMessage.thread?.name) {
+            try {
+              const authClient = await getAuthClient();
+              const chatApi = google.chat({ version: 'v1', auth: authClient });
+              const response = await chatApi.spaces.messages.list({
+                parent: externalContextId,
+                filter: `thread.name="${eventMessage.thread.name}"`,
+              });
+              isReplyToBot =
+                response.data.messages?.some(
+                  (m) =>
+                    m.sender?.type === 'BOT' ||
+                    m.annotations?.some(
+                      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                      (a: any) => a.type === 'USER_MENTION' && a.userMention?.user?.type === 'BOT'
+                    )
+                ) ?? false;
+            } catch (err) {
+              console.error('Failed to fetch thread messages for mention check:', err);
+            }
+          }
+
+          // If requireMention is true and it's not a DM, ignore if not mentioned and not a thread reply to the bot.
+          if (!isMentioned && !isReplyToBot) {
+            message.ack();
+            return;
+          }
+        }
+      }
+
+      if (eventType === 'CARD_CLICKED') {
+        await handleCardClicked(
+          parsedData,
+          targetChatId as string,
+          trpc as unknown as RoutingTrpcClient
+        );
+        message.ack();
+        return;
+      }
+
+      const commandResult = await handleAdapterCommand(
+        text,
+        filteringConfig,
+        trpc as unknown as CommandTrpcClient,
+        targetChatId
+      );
+
+      if (commandResult) {
+        let resultText = '';
+        if (commandResult.type === 'text') {
+          if (commandResult.newConfig) {
+            filteringConfig.filters = commandResult.newConfig.filters;
+            await updateGoogleChatState({ filters: filteringConfig.filters });
+          }
+          resultText = commandResult.text;
+        } else if (commandResult.type === 'debug') {
+          resultText =
+            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');
+        }
+
+        const authClient = await getAuthClient();
+        const chatApi = google.chat({ version: 'v1', auth: authClient });
+        await chatApi.spaces.messages.create({
+          parent: spaceName as string,
+          requestBody: { text: resultText },
+        });
+        message.ack();
+        return;
+      }
+      const attachments = eventMessage?.attachment || [];
+
+      if (attachments.length > 0) {
+        const tmpDir = path.join(getClawminiDir(process.cwd()), 'tmp', 'google-chat');
+        await fsPromises.mkdir(tmpDir, { recursive: true });
+
+        for (const att of attachments) {
+          const resourceName = att.attachmentDataRef?.resourceName;
+          if (resourceName) {
+            try {
+              const buffer = await downloadAttachment(resourceName, config.maxAttachmentSizeMB);
+              const uniqueName = `${crypto.randomUUID()}-${att.contentName || 'attachment'}`;
+              const filePath = path.join(tmpDir, uniqueName);
+              await fsPromises.writeFile(filePath, buffer);
+              downloadedFiles.push(filePath);
+            } catch (err) {
+              console.error(`Error downloading attachment:`, err);
+            }
+          }
+        }
+      }
+
+      await trpc.sendMessage.mutate({
+        type: 'send-message',
+        client: 'cli',
+        data: {
+          message: text,
+          chatId: targetChatId,
+          files: downloadedFiles.length > 0 ? downloadedFiles : undefined,
+          adapter: 'google-chat',
+          noWait: true,
+        },
+      });
+
+      console.log(`Forwarded message from ${identifier} to daemon.`);
+      message.ack();
+    } catch (error) {
+      console.error('Error processing Pub/Sub message:', error);
+      for (const file of downloadedFiles) {
+        try {
+          await fsPromises.unlink(file);
+        } catch (unlinkErr) {
+          console.error(`Failed to delete downloaded file ${file} after error:`, unlinkErr);
+        }
+      }
+      // Add a brief artificial delay before nacking to avoid tight retry loops
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+      // Nack the message so it can be retried if it's a transient failure
+      message.nack();
+    }
+  });
+
+  subscription.on('error', (error) => {
+    console.error('Pub/Sub subscription error:', error);
+  });
+
+  return subscription;
+}

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

@@ -0,0 +1,187 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import fsPromises from 'node:fs/promises';
+import fs from 'node:fs';
+import {
+  GoogleChatConfigSchema,
+  isAuthorized,
+  readGoogleChatConfig,
+  getGoogleChatConfigPath,
+} from './config.js';
+
+vi.mock('node:fs/promises');
+vi.mock('node:fs', () => ({
+  default: {
+    existsSync: vi.fn(),
+  },
+  existsSync: vi.fn(),
+}));
+vi.mock('../shared/workspace.js', () => ({
+  getClawminiDir: () => '/mock/clawmini',
+}));
+
+describe('Google Chat Adapter Configuration', () => {
+  describe('GoogleChatConfigSchema', () => {
+    it('should validate a correct configuration', () => {
+      const config = {
+        projectId: 'test-project',
+        subscriptionName: 'test-sub',
+        topicName: 'test-topic',
+        authorizedUsers: ['test@example.com'],
+      };
+      const result = GoogleChatConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data).toEqual({
+          ...config,
+          maxAttachmentSizeMB: 25,
+          chatId: 'default',
+          driveUploadEnabled: true,
+          requireMention: false,
+        });
+      }
+    });
+
+    it('should validate a custom maxAttachmentSizeMB', () => {
+      const config = {
+        projectId: 'test-project',
+        subscriptionName: 'test-sub',
+        topicName: 'test-topic',
+        authorizedUsers: ['test@example.com'],
+        maxAttachmentSizeMB: 50,
+      };
+      const result = GoogleChatConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.maxAttachmentSizeMB).toBe(50);
+      }
+    });
+
+    it('should validate messages property', () => {
+      const config = {
+        projectId: 'test-project',
+        subscriptionName: 'test-sub',
+        topicName: 'test-topic',
+        authorizedUsers: ['test@example.com'],
+        messages: { all: true, test: false },
+      };
+      const result = GoogleChatConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.messages).toEqual({ all: true, test: false });
+      }
+    });
+
+    it('should fail validation if fields are missing', () => {
+      const result = GoogleChatConfigSchema.safeParse({});
+      expect(result.success).toBe(false);
+    });
+
+    it('should fail validation if fields are empty', () => {
+      const result = GoogleChatConfigSchema.safeParse({
+        projectId: '',
+        subscriptionName: '',
+        topicName: 'test-topic',
+        authorizedUsers: [],
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe('isAuthorized', () => {
+    it('should return true if user ID or email is in authorized users list', () => {
+      expect(isAuthorized('user@example.com', ['user@example.com', 'other@example.com'])).toBe(
+        true
+      );
+    });
+
+    it('should return false if user ID or email is not in authorized users list', () => {
+      expect(isAuthorized('unauthorized@example.com', ['user@example.com'])).toBe(false);
+    });
+  });
+
+  describe('initGoogleChatConfig', () => {
+    beforeEach(async () => {
+      vi.clearAllMocks();
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+    });
+
+    it('should create directory and template config file if they do not exist', async () => {
+      const { initGoogleChatConfig } = await import('./config.js');
+      await initGoogleChatConfig();
+
+      expect(fsPromises.mkdir).toHaveBeenCalledWith('/mock/clawmini/adapters/google-chat', {
+        recursive: true,
+      });
+      expect(fsPromises.writeFile).toHaveBeenCalled();
+      const writeCall = vi.mocked(fsPromises.writeFile).mock.calls[0];
+      expect(writeCall![0]).toBe(getGoogleChatConfigPath());
+      expect(JSON.parse(writeCall![1] as string)).toEqual({
+        projectId: 'YOUR_PROJECT_ID',
+        subscriptionName: 'YOUR_SUBSCRIPTION_NAME',
+        topicName: 'YOUR_TOPIC_NAME',
+        authorizedUsers: ['user@example.com'],
+        chatId: 'default',
+        requireMention: false,
+        oauthClientId: 'YOUR_OAUTH_CLIENT_ID',
+        oauthClientSecret: 'YOUR_OAUTH_CLIENT_SECRET',
+      });
+    });
+
+    it('should not overwrite existing config file', async () => {
+      vi.mocked(fs.existsSync).mockReturnValue(true);
+      const { initGoogleChatConfig } = await import('./config.js');
+      await initGoogleChatConfig();
+
+      expect(fsPromises.writeFile).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('readGoogleChatConfig', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should successfully read and parse a valid config file', async () => {
+      const mockConfig = {
+        projectId: 'test-project',
+        subscriptionName: 'test-sub',
+        topicName: 'test-topic',
+        authorizedUsers: ['user@example.com'],
+      };
+      vi.mocked(fsPromises.readFile).mockResolvedValue(JSON.stringify(mockConfig));
+
+      const config = await readGoogleChatConfig();
+      expect(config).toEqual({
+        ...mockConfig,
+        maxAttachmentSizeMB: 25,
+        chatId: 'default',
+        driveUploadEnabled: true,
+        requireMention: false,
+      });
+      expect(fsPromises.readFile).toHaveBeenCalledWith(getGoogleChatConfigPath(), 'utf-8');
+    });
+
+    it('should return null if the config file does not exist', async () => {
+      const error = new Error('File not found') as Error & { code: string };
+      error.code = 'ENOENT';
+      vi.mocked(fsPromises.readFile).mockRejectedValue(error);
+
+      const config = await readGoogleChatConfig();
+      expect(config).toBeNull();
+    });
+
+    it('should throw if the config file contains invalid JSON', async () => {
+      vi.mocked(fsPromises.readFile).mockResolvedValue('invalid-json');
+
+      await expect(readGoogleChatConfig()).rejects.toThrow();
+    });
+
+    it('should throw if the config fails schema validation', async () => {
+      vi.mocked(fsPromises.readFile).mockResolvedValue(
+        JSON.stringify({ subscriptionName: 'test' })
+      );
+
+      await expect(readGoogleChatConfig()).rejects.toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,82 @@
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { z } from 'zod';
+import { getClawminiDir } from '../shared/workspace.js';
+import fs from 'node:fs';
+
+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.'),
+  topicName: z.string().min(1, 'Pub/Sub Topic Name is required.'),
+  authorizedUsers: z.array(z.string()).min(1, 'At least one Authorized User is required.'),
+  maxAttachmentSizeMB: z.number().default(25).optional(),
+  chatId: z.string().default('default').optional(),
+  directMessageName: z.string().optional(),
+  driveUploadEnabled: z.boolean().default(true).optional(),
+  requireMention: z.boolean().default(false),
+  oauthClientId: z.string().optional(),
+  oauthClientSecret: z.string().optional(),
+});
+
+export type GoogleChatConfig = z.infer<typeof GoogleChatConfigSchema>;
+
+export function getGoogleChatConfigPath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'adapters', 'google-chat', 'config.json');
+}
+
+export async function readGoogleChatConfig(
+  startDir = process.cwd()
+): Promise<GoogleChatConfig | null> {
+  const configPath = getGoogleChatConfigPath(startDir);
+  try {
+    const data = await fsPromises.readFile(configPath, 'utf-8');
+    const parsed = JSON.parse(data);
+    return GoogleChatConfigSchema.parse(parsed);
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+      return null;
+    }
+    throw err;
+  }
+}
+
+export async function updateGoogleChatConfig(
+  config: GoogleChatConfig,
+  startDir = process.cwd()
+): Promise<void> {
+  const configPath = getGoogleChatConfigPath(startDir);
+  await fsPromises.writeFile(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}
+
+export async function initGoogleChatConfig(startDir = process.cwd()): Promise<void> {
+  const configPath = getGoogleChatConfigPath(startDir);
+  const configDir = path.dirname(configPath);
+
+  await fsPromises.mkdir(configDir, { recursive: true });
+
+  if (fs.existsSync(configPath)) {
+    console.log(`Config file already exists at ${configPath}`);
+    return;
+  }
+
+  const templateConfig = {
+    projectId: 'YOUR_PROJECT_ID',
+    topicName: 'YOUR_TOPIC_NAME',
+    subscriptionName: 'YOUR_SUBSCRIPTION_NAME',
+    authorizedUsers: ['user@example.com'],
+    chatId: 'default',
+    requireMention: false,
+    oauthClientId: 'YOUR_OAUTH_CLIENT_ID',
+    oauthClientSecret: 'YOUR_OAUTH_CLIENT_SECRET',
+  };
+
+  await fsPromises.writeFile(configPath, JSON.stringify(templateConfig, null, 2), 'utf-8');
+  console.log(`Created template configuration file at ${configPath}`);
+  console.log(
+    'Please update it with your actual GCP Project ID, Pub/Sub Topic Name, Pub/Sub Subscription Name, and Authorized Users.'
+  );
+}
+
+export function isAuthorized(userIdOrEmail: string, authorizedUsers: string[]): boolean {
+  return authorizedUsers.some((u) => u.toLowerCase() === userIdOrEmail.toLowerCase());
+}