cowork-os 0.3.21

package/dist/electron/electron/gateway/channels/google-chat.js

@@ -0,0 +1,631 @@
+"use strict";
+/**
+ * Google Chat Channel Adapter
+ *
+ * Implements the ChannelAdapter interface using Google Chat API.
+ * Supports direct messages, spaces, and threaded conversations.
+ *
+ * Authentication: Service Account with Domain-Wide Delegation
+ * Message reception: HTTP webhook or Pub/Sub subscription
+ * Message sending: Google Chat REST API
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleChatAdapter = void 0;
+exports.createGoogleChatAdapter = createGoogleChatAdapter;
+const http = __importStar(require("http"));
+const https = __importStar(require("https"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+/**
+ * Simple TTL cache for message deduplication
+ */
+class MessageDeduplicationCache {
+    constructor(ttlMs = 60000) {
+        this.cache = new Map();
+        this.ttlMs = ttlMs;
+        this.cleanupInterval = setInterval(() => this.cleanup(), 60000);
+    }
+    has(messageId) {
+        const timestamp = this.cache.get(messageId);
+        if (!timestamp)
+            return false;
+        if (Date.now() - timestamp > this.ttlMs) {
+            this.cache.delete(messageId);
+            return false;
+        }
+        return true;
+    }
+    add(messageId) {
+        this.cache.set(messageId, Date.now());
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [key, timestamp] of this.cache.entries()) {
+            if (now - timestamp > this.ttlMs) {
+                this.cache.delete(key);
+            }
+        }
+    }
+    destroy() {
+        clearInterval(this.cleanupInterval);
+        this.cache.clear();
+    }
+}
+/**
+ * Google OAuth2 token manager for service account
+ */
+class GoogleAuthManager {
+    constructor(credentials) {
+        this.accessToken = null;
+        this.tokenExpiry = 0;
+        this.credentials = credentials;
+    }
+    async getAccessToken() {
+        if (this.accessToken && Date.now() < this.tokenExpiry - 60000) {
+            return this.accessToken;
+        }
+        const jwt = this.createJWT();
+        const token = await this.exchangeJWTForToken(jwt);
+        this.accessToken = token.access_token;
+        this.tokenExpiry = Date.now() + (token.expires_in * 1000);
+        return this.accessToken;
+    }
+    createJWT() {
+        const header = {
+            alg: 'RS256',
+            typ: 'JWT',
+        };
+        const now = Math.floor(Date.now() / 1000);
+        const payload = {
+            iss: this.credentials.client_email,
+            scope: 'https://www.googleapis.com/auth/chat.bot',
+            aud: 'https://oauth2.googleapis.com/token',
+            iat: now,
+            exp: now + 3600,
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64url');
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64url');
+        const signatureInput = `${encodedHeader}.${encodedPayload}`;
+        const sign = crypto.createSign('RSA-SHA256');
+        sign.update(signatureInput);
+        const signature = sign.sign(this.credentials.private_key, 'base64url');
+        return `${signatureInput}.${signature}`;
+    }
+    async exchangeJWTForToken(jwt) {
+        return new Promise((resolve, reject) => {
+            const postData = new URLSearchParams({
+                grant_type: 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+                assertion: jwt,
+            }).toString();
+            const options = {
+                hostname: 'oauth2.googleapis.com',
+                port: 443,
+                path: '/token',
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    'Content-Length': Buffer.byteLength(postData),
+                },
+            };
+            const req = https.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => { data += chunk; });
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (parsed.error) {
+                            reject(new Error(`Token exchange failed: ${parsed.error_description || parsed.error}`));
+                        }
+                        else {
+                            resolve(parsed);
+                        }
+                    }
+                    catch (e) {
+                        reject(new Error(`Failed to parse token response: ${data}`));
+                    }
+                });
+            });
+            req.on('error', reject);
+            req.write(postData);
+            req.end();
+        });
+    }
+}
+class GoogleChatAdapter {
+    constructor(config) {
+        this.type = 'googlechat';
+        this.server = null;
+        this.authManager = null;
+        this._status = 'disconnected';
+        this.messageHandlers = [];
+        this.errorHandlers = [];
+        this.statusHandlers = [];
+        this.reconnectAttempts = 0;
+        this.reconnectTimer = null;
+        this.config = config;
+        this.deduplicationCache = new MessageDeduplicationCache();
+    }
+    get status() {
+        return this._status;
+    }
+    get botUsername() {
+        return this._botUsername;
+    }
+    /**
+     * Connect to Google Chat via webhook server
+     */
+    async connect() {
+        if (this._status === 'connected' || this._status === 'connecting') {
+            return;
+        }
+        this.setStatus('connecting');
+        try {
+            // Load service account credentials
+            const credentials = await this.loadCredentials();
+            this.authManager = new GoogleAuthManager(credentials);
+            // Verify credentials by getting a token
+            await this.authManager.getAccessToken();
+            // Set bot info from config
+            this._botUsername = this.config.displayName || 'Google Chat Bot';
+            // Start the HTTP server for receiving webhooks
+            await this.startWebhookServer();
+            console.log(`Google Chat bot "${this._botUsername}" is connected on port ${this.config.webhookPort || 3979}`);
+            this.setStatus('connected');
+            this.reconnectAttempts = 0;
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.setStatus('error', err);
+            this.scheduleReconnect();
+            throw err;
+        }
+    }
+    /**
+     * Load service account credentials
+     */
+    async loadCredentials() {
+        // Check for inline credentials first
+        if (this.config.serviceAccountKey) {
+            return this.config.serviceAccountKey;
+        }
+        // Check for key file path
+        if (this.config.serviceAccountKeyPath) {
+            const keyPath = this.config.serviceAccountKeyPath;
+            if (!fs.existsSync(keyPath)) {
+                throw new Error(`Service account key file not found: ${keyPath}`);
+            }
+            const keyContent = fs.readFileSync(keyPath, 'utf-8');
+            const key = JSON.parse(keyContent);
+            return {
+                client_email: key.client_email,
+                private_key: key.private_key,
+                project_id: key.project_id,
+            };
+        }
+        // Check for GOOGLE_APPLICATION_CREDENTIALS environment variable
+        const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+        if (envPath && fs.existsSync(envPath)) {
+            const keyContent = fs.readFileSync(envPath, 'utf-8');
+            const key = JSON.parse(keyContent);
+            return {
+                client_email: key.client_email,
+                private_key: key.private_key,
+                project_id: key.project_id,
+            };
+        }
+        throw new Error('Google Chat credentials not configured. Provide serviceAccountKey or serviceAccountKeyPath.');
+    }
+    /**
+     * Start the webhook server to receive messages from Google Chat
+     */
+    async startWebhookServer() {
+        const port = this.config.webhookPort || 3979;
+        const webhookPath = this.config.webhookPath || '/googlechat/webhook';
+        return new Promise((resolve, reject) => {
+            this.server = http.createServer(async (req, res) => {
+                if (req.method === 'POST' && req.url === webhookPath) {
+                    let body = '';
+                    req.on('data', chunk => {
+                        body += chunk.toString();
+                    });
+                    req.on('end', async () => {
+                        try {
+                            await this.processIncomingEvent(req, res, body);
+                        }
+                        catch (error) {
+                            console.error('Error processing Google Chat event:', error);
+                            res.writeHead(500);
+                            res.end(JSON.stringify({ error: 'Internal Server Error' }));
+                        }
+                    });
+                }
+                else if (req.method === 'GET' && req.url === '/health') {
+                    // Health check endpoint
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ status: 'ok', bot: this._botUsername }));
+                }
+                else {
+                    res.writeHead(404);
+                    res.end('Not Found');
+                }
+            });
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    reject(new Error(`Port ${port} is already in use. Please choose a different webhook port.`));
+                }
+                else if (error.code === 'EACCES') {
+                    reject(new Error(`Permission denied to use port ${port}. Try a port above 1024.`));
+                }
+                else {
+                    reject(error);
+                }
+            });
+            this.server.listen(port, () => {
+                console.log(`Google Chat webhook server listening on port ${port} at ${webhookPath}`);
+                resolve();
+            });
+        });
+    }
+    /**
+     * Process incoming event from Google Chat
+     */
+    async processIncomingEvent(req, res, body) {
+        try {
+            const event = JSON.parse(body);
+            // Handle different event types
+            switch (event.type) {
+                case 'MESSAGE':
+                    await this.handleMessage(event);
+                    // Respond with empty JSON to acknowledge
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end('{}');
+                    break;
+                case 'ADDED_TO_SPACE':
+                    console.log(`Bot added to space: ${event.space?.displayName || event.space?.name}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({
+                        text: `Hello! I'm ${this._botUsername}. How can I help you today?`,
+                    }));
+                    break;
+                case 'REMOVED_FROM_SPACE':
+                    console.log(`Bot removed from space: ${event.space?.displayName || event.space?.name}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end('{}');
+                    break;
+                case 'CARD_CLICKED':
+                    // Handle interactive card clicks
+                    console.log(`Card clicked: ${event.action?.actionMethodName}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end('{}');
+                    break;
+                default:
+                    console.log(`Unhandled Google Chat event type: ${event.type}`);
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end('{}');
+            }
+        }
+        catch (error) {
+            console.error('Error parsing Google Chat event:', error);
+            res.writeHead(400);
+            res.end(JSON.stringify({ error: 'Bad Request' }));
+        }
+    }
+    /**
+     * Handle incoming message event
+     */
+    async handleMessage(event) {
+        const message = event.message;
+        if (!message) {
+            return;
+        }
+        // Skip bot's own messages
+        if (message.sender?.type === 'BOT') {
+            return;
+        }
+        // Get message text (use argumentText for @mentions, otherwise use text)
+        const text = message.argumentText?.trim() || message.text?.trim();
+        if (!text) {
+            return;
+        }
+        // Extract message ID from name (format: spaces/{space}/messages/{message})
+        const messageId = message.name.split('/').pop() || message.name;
+        // Deduplication check
+        if (this.config.deduplicationEnabled !== false && this.deduplicationCache.has(messageId)) {
+            console.log(`Skipping duplicate Google Chat message: ${messageId}`);
+            return;
+        }
+        this.deduplicationCache.add(messageId);
+        // Extract space ID (format: spaces/{space})
+        const spaceId = message.space.name;
+        // Get user info
+        const userName = message.sender?.displayName || 'Unknown User';
+        const userId = message.sender?.name || '';
+        // Map to IncomingMessage format
+        const incomingMessage = {
+            messageId: messageId,
+            channel: 'googlechat',
+            userId: userId,
+            userName: userName,
+            chatId: spaceId,
+            text: text,
+            timestamp: message.createTime ? new Date(message.createTime) : new Date(),
+            threadId: message.thread?.name,
+            raw: event,
+        };
+        console.log(`Processing Google Chat message from ${userName}: ${text.slice(0, 50)}...`);
+        await this.handleIncomingMessage(incomingMessage);
+    }
+    /**
+     * Schedule reconnection with exponential backoff
+     */
+    scheduleReconnect() {
+        if (!this.config.autoReconnect)
+            return;
+        const maxAttempts = this.config.maxReconnectAttempts || 5;
+        if (this.reconnectAttempts >= maxAttempts) {
+            console.error(`Google Chat: Max reconnection attempts (${maxAttempts}) reached`);
+            return;
+        }
+        const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+        this.reconnectAttempts++;
+        console.log(`Google Chat: Scheduling reconnection attempt ${this.reconnectAttempts} in ${delay}ms`);
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+        }
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this.connect();
+            }
+            catch (error) {
+                console.error('Google Chat reconnection failed:', error);
+            }
+        }, delay);
+    }
+    /**
+     * Disconnect from Google Chat
+     */
+    async disconnect() {
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server.close(() => resolve());
+            });
+            this.server = null;
+        }
+        this.deduplicationCache.destroy();
+        this.authManager = null;
+        this._botUsername = undefined;
+        this.setStatus('disconnected');
+    }
+    /**
+     * Send a message to a Google Chat space
+     */
+    async sendMessage(message) {
+        if (!this.authManager || this._status !== 'connected') {
+            throw new Error('Google Chat bot is not connected');
+        }
+        const accessToken = await this.authManager.getAccessToken();
+        // Prepare message payload
+        const payload = {
+            text: message.text,
+        };
+        // Add thread if specified
+        if (message.threadId) {
+            payload.thread = { name: message.threadId };
+        }
+        // Build the API URL
+        // Format: spaces/{space}/messages
+        const apiUrl = `https://chat.googleapis.com/v1/${message.chatId}/messages`;
+        try {
+            const response = await this.makeApiRequest('POST', apiUrl, accessToken, payload);
+            return response.name || '';
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.error('Error sending Google Chat message:', errorMessage);
+            throw error;
+        }
+    }
+    /**
+     * Make an authenticated API request to Google Chat
+     */
+    async makeApiRequest(method, url, accessToken, body) {
+        return new Promise((resolve, reject) => {
+            const urlObj = new URL(url);
+            const postData = body ? JSON.stringify(body) : undefined;
+            const options = {
+                hostname: urlObj.hostname,
+                port: 443,
+                path: urlObj.pathname + urlObj.search,
+                method: method,
+                headers: {
+                    'Authorization': `Bearer ${accessToken}`,
+                    'Content-Type': 'application/json',
+                },
+            };
+            if (postData) {
+                options.headers['Content-Length'] = Buffer.byteLength(postData);
+            }
+            const req = https.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => { data += chunk; });
+                res.on('end', () => {
+                    try {
+                        const parsed = JSON.parse(data);
+                        if (res.statusCode && res.statusCode >= 400) {
+                            reject(new Error(`API error ${res.statusCode}: ${parsed.error?.message || data}`));
+                        }
+                        else {
+                            resolve(parsed);
+                        }
+                    }
+                    catch (e) {
+                        if (res.statusCode && res.statusCode >= 400) {
+                            reject(new Error(`API error ${res.statusCode}: ${data}`));
+                        }
+                        else {
+                            resolve({});
+                        }
+                    }
+                });
+            });
+            req.on('error', reject);
+            if (postData) {
+                req.write(postData);
+            }
+            req.end();
+        });
+    }
+    /**
+     * Edit an existing message
+     */
+    async editMessage(chatId, messageId, text) {
+        if (!this.authManager || this._status !== 'connected') {
+            throw new Error('Google Chat bot is not connected');
+        }
+        const accessToken = await this.authManager.getAccessToken();
+        // Build the message name (format: spaces/{space}/messages/{message})
+        const messageName = messageId.includes('/') ? messageId : `${chatId}/messages/${messageId}`;
+        const apiUrl = `https://chat.googleapis.com/v1/${messageName}?updateMask=text`;
+        const payload = { text };
+        await this.makeApiRequest('PATCH', apiUrl, accessToken, payload);
+    }
+    /**
+     * Delete a message
+     */
+    async deleteMessage(chatId, messageId) {
+        if (!this.authManager || this._status !== 'connected') {
+            throw new Error('Google Chat bot is not connected');
+        }
+        const accessToken = await this.authManager.getAccessToken();
+        // Build the message name
+        const messageName = messageId.includes('/') ? messageId : `${chatId}/messages/${messageId}`;
+        const apiUrl = `https://chat.googleapis.com/v1/${messageName}`;
+        await this.makeApiRequest('DELETE', apiUrl, accessToken);
+    }
+    /**
+     * Send a document/file to a space
+     * Note: Google Chat has limited file attachment support via API
+     */
+    async sendDocument(chatId, filePath, caption) {
+        // Google Chat API doesn't support direct file uploads
+        // Files must be uploaded to Google Drive first
+        // For now, send a message with the file path/name
+        const fileName = path.basename(filePath);
+        const message = caption ? `${caption}\n📎 ${fileName}` : `📎 ${fileName}`;
+        return this.sendMessage({
+            chatId,
+            text: message,
+        });
+    }
+    /**
+     * Register a message handler
+     */
+    onMessage(handler) {
+        this.messageHandlers.push(handler);
+    }
+    /**
+     * Register an error handler
+     */
+    onError(handler) {
+        this.errorHandlers.push(handler);
+    }
+    /**
+     * Register a status change handler
+     */
+    onStatusChange(handler) {
+        this.statusHandlers.push(handler);
+    }
+    /**
+     * Get channel info
+     */
+    async getInfo() {
+        return {
+            type: 'googlechat',
+            status: this._status,
+            botUsername: this._botUsername,
+            botDisplayName: this._botUsername,
+        };
+    }
+    // Private helper methods
+    async handleIncomingMessage(message) {
+        for (const handler of this.messageHandlers) {
+            try {
+                await handler(message);
+            }
+            catch (error) {
+                console.error('Error in message handler:', error);
+                this.handleError(error instanceof Error ? error : new Error(String(error)), 'messageHandler');
+            }
+        }
+    }
+    handleError(error, context) {
+        for (const handler of this.errorHandlers) {
+            try {
+                handler(error, context);
+            }
+            catch (e) {
+                console.error('Error in error handler:', e);
+            }
+        }
+    }
+    setStatus(status, error) {
+        this._status = status;
+        for (const handler of this.statusHandlers) {
+            try {
+                handler(status, error);
+            }
+            catch (e) {
+                console.error('Error in status handler:', e);
+            }
+        }
+    }
+}
+exports.GoogleChatAdapter = GoogleChatAdapter;
+/**
+ * Create a Google Chat adapter from configuration
+ */
+function createGoogleChatAdapter(config) {
+    // At least one credential source must be provided
+    if (!config.serviceAccountKey && !config.serviceAccountKeyPath && !process.env.GOOGLE_APPLICATION_CREDENTIALS) {
+        throw new Error('Google Chat requires service account credentials (serviceAccountKey, serviceAccountKeyPath, or GOOGLE_APPLICATION_CREDENTIALS)');
+    }
+    return new GoogleChatAdapter(config);
+}