cowork-os 0.3.21

package/dist/electron/electron/hooks/server.js

@@ -0,0 +1,480 @@
+"use strict";
+/**
+ * Hooks Webhook Server
+ *
+ * HTTP server for webhook endpoints (wake/agent/custom mappings).
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksServer = void 0;
+exports.resolveHooksConfig = resolveHooksConfig;
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+const crypto_1 = __importDefault(require("crypto"));
+const types_1 = require("./types");
+const mappings_1 = require("./mappings");
+/**
+ * Resolve hooks configuration
+ */
+function resolveHooksConfig(config) {
+    if (config.enabled !== true)
+        return null;
+    const token = config.token?.trim();
+    if (!token) {
+        throw new Error('hooks.enabled requires hooks.token');
+    }
+    const rawPath = config.path?.trim() || types_1.DEFAULT_HOOKS_PATH;
+    const withSlash = rawPath.startsWith('/') ? rawPath : `/${rawPath}`;
+    const trimmed = withSlash.length > 1 ? withSlash.replace(/\/+$/, '') : withSlash;
+    if (trimmed === '/') {
+        throw new Error('hooks.path may not be "/"');
+    }
+    const maxBodyBytes = config.maxBodyBytes && config.maxBodyBytes > 0
+        ? config.maxBodyBytes
+        : types_1.DEFAULT_HOOKS_MAX_BODY_BYTES;
+    const mappings = (0, mappings_1.resolveHookMappings)(config);
+    return {
+        basePath: trimmed,
+        token,
+        maxBodyBytes,
+        mappings,
+    };
+}
+class HooksServer {
+    constructor(config) {
+        this.server = null;
+        this.hooksConfig = null;
+        this.handlers = {};
+        this.config = config;
+    }
+    /**
+     * Set the hooks configuration (call before start)
+     */
+    setHooksConfig(config) {
+        this.hooksConfig = resolveHooksConfig(config);
+    }
+    /**
+     * Set handlers for hook actions
+     */
+    setHandlers(handlers) {
+        this.handlers = handlers;
+    }
+    /**
+     * Start the webhook server
+     */
+    async start() {
+        if (!this.config.enabled) {
+            console.log('[HooksServer] Server disabled');
+            return;
+        }
+        if (this.server) {
+            console.log('[HooksServer] Server already running');
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            this.server = http_1.default.createServer((req, res) => {
+                this.handleRequest(req, res).catch((err) => {
+                    console.error('[HooksServer] Request error:', err);
+                    this.sendJsonResponse(res, 500, { success: false, error: 'Internal server error' });
+                });
+            });
+            this.server.on('error', (err) => {
+                console.error('[HooksServer] Server error:', err);
+                this.emitEvent({ action: 'error', timestamp: Date.now(), error: String(err) });
+                reject(err);
+            });
+            const host = this.config.host || '127.0.0.1';
+            this.server.listen(this.config.port, host, () => {
+                console.log(`[HooksServer] Server listening on http://${host}:${this.config.port}`);
+                this.emitEvent({ action: 'started', timestamp: Date.now() });
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the webhook server
+     */
+    async stop() {
+        if (!this.server)
+            return;
+        return new Promise((resolve) => {
+            this.server.close(() => {
+                console.log('[HooksServer] Server stopped');
+                this.emitEvent({ action: 'stopped', timestamp: Date.now() });
+                this.server = null;
+                resolve();
+            });
+        });
+    }
+    /**
+     * Check if the server is running
+     */
+    isRunning() {
+        return this.server !== null;
+    }
+    /**
+     * Get the server address
+     */
+    getAddress() {
+        if (!this.server)
+            return null;
+        const addr = this.server.address();
+        if (typeof addr === 'string' || !addr)
+            return null;
+        return { host: addr.address, port: addr.port };
+    }
+    /**
+     * Handle incoming HTTP request
+     */
+    async handleRequest(req, res) {
+        // Set CORS headers
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization, X-CoWork-Token');
+        // Handle preflight
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        const url = new url_1.URL(req.url || '/', `http://${req.headers.host || 'localhost'}`);
+        // Health check endpoint
+        if (url.pathname === '/health' && req.method === 'GET') {
+            this.sendJsonResponse(res, 200, { status: 'ok', timestamp: Date.now() });
+            return;
+        }
+        // Check if hooks are configured
+        if (!this.hooksConfig) {
+            this.sendJsonResponse(res, 503, { success: false, error: 'Hooks not configured' });
+            return;
+        }
+        const basePath = this.hooksConfig.basePath;
+        // Check if request is for hooks path
+        if (!url.pathname.startsWith(basePath)) {
+            this.sendJsonResponse(res, 404, { success: false, error: 'Not found' });
+            return;
+        }
+        // Extract the hook path after base
+        const hookPath = url.pathname.slice(basePath.length).replace(/^\/+/, '');
+        // Emit request event
+        this.emitEvent({
+            action: 'request',
+            timestamp: Date.now(),
+            path: hookPath,
+            method: req.method,
+        });
+        // Verify authentication
+        const tokenResult = this.extractHookToken(req, url);
+        if (!this.verifyToken(tokenResult.token)) {
+            this.sendJsonResponse(res, 401, { success: false, error: 'Invalid or missing token' });
+            return;
+        }
+        if (tokenResult.fromQuery) {
+            console.warn('[HooksServer] Token provided via query param (deprecated)');
+        }
+        // Handle specific endpoints
+        if (hookPath === 'wake' && req.method === 'POST') {
+            await this.handleWake(req, res);
+            return;
+        }
+        if (hookPath === 'agent' && req.method === 'POST') {
+            await this.handleAgent(req, res);
+            return;
+        }
+        // Handle mapped endpoints
+        if (req.method === 'POST') {
+            await this.handleMapped(req, res, url, hookPath);
+            return;
+        }
+        this.sendJsonResponse(res, 404, { success: false, error: 'Not found' });
+    }
+    /**
+     * Handle /hooks/wake endpoint
+     */
+    async handleWake(req, res) {
+        const body = await this.parseJsonBody(req);
+        if (!body) {
+            this.sendJsonResponse(res, 400, { success: false, error: 'Invalid JSON body' });
+            return;
+        }
+        const text = body.text?.trim();
+        if (!text) {
+            this.sendJsonResponse(res, 400, { success: false, error: 'text required' });
+            return;
+        }
+        const mode = body.mode === 'next-heartbeat' ? 'next-heartbeat' : 'now';
+        if (this.handlers.onWake) {
+            try {
+                await this.handlers.onWake({ text, mode });
+                this.sendJsonResponse(res, 200, { success: true });
+            }
+            catch (error) {
+                console.error('[HooksServer] Wake handler error:', error);
+                this.sendJsonResponse(res, 500, { success: false, error: String(error) });
+            }
+        }
+        else {
+            this.sendJsonResponse(res, 503, { success: false, error: 'Wake handler not configured' });
+        }
+    }
+    /**
+     * Handle /hooks/agent endpoint
+     */
+    async handleAgent(req, res) {
+        const body = await this.parseJsonBody(req);
+        if (!body) {
+            this.sendJsonResponse(res, 400, { success: false, error: 'Invalid JSON body' });
+            return;
+        }
+        const message = body.message?.trim();
+        if (!message) {
+            this.sendJsonResponse(res, 400, { success: false, error: 'message required' });
+            return;
+        }
+        const agentPayload = {
+            message,
+            name: body.name?.trim(),
+            wakeMode: (body.wakeMode === 'next-heartbeat' ? 'next-heartbeat' : 'now'),
+            sessionKey: body.sessionKey?.trim(),
+            deliver: body.deliver ?? true,
+            channel: body.channel,
+            to: body.to?.trim(),
+            model: body.model?.trim(),
+            thinking: body.thinking?.trim(),
+            timeoutSeconds: body.timeoutSeconds,
+            workspaceId: body.workspaceId?.trim(),
+        };
+        if (this.handlers.onAgent) {
+            try {
+                const result = await this.handlers.onAgent(agentPayload);
+                // Return 202 Accepted for async operation
+                this.sendJsonResponse(res, 202, { success: true, taskId: result.taskId });
+            }
+            catch (error) {
+                console.error('[HooksServer] Agent handler error:', error);
+                this.sendJsonResponse(res, 500, { success: false, error: String(error) });
+            }
+        }
+        else {
+            this.sendJsonResponse(res, 503, { success: false, error: 'Agent handler not configured' });
+        }
+    }
+    /**
+     * Handle mapped endpoints (e.g., /hooks/gmail)
+     */
+    async handleMapped(req, res, url, hookPath) {
+        if (!this.hooksConfig) {
+            this.sendJsonResponse(res, 503, { success: false, error: 'Hooks not configured' });
+            return;
+        }
+        const body = await this.parseJsonBody(req);
+        if (!body) {
+            this.sendJsonResponse(res, 400, { success: false, error: 'Invalid JSON body' });
+            return;
+        }
+        const headers = this.normalizeHeaders(req);
+        const ctx = {
+            payload: body,
+            headers,
+            url,
+            path: hookPath,
+        };
+        const result = await (0, mappings_1.applyHookMappings)(this.hooksConfig.mappings, ctx);
+        if (!result) {
+            this.sendJsonResponse(res, 404, { success: false, error: 'No matching hook mapping' });
+            return;
+        }
+        if (!result.ok) {
+            this.sendJsonResponse(res, 400, { success: false, error: result.error });
+            return;
+        }
+        if ('skipped' in result && result.skipped) {
+            this.sendJsonResponse(res, 200, { success: true, skipped: true });
+            return;
+        }
+        const action = result.action;
+        if (!action) {
+            this.sendJsonResponse(res, 200, { success: true, skipped: true });
+            return;
+        }
+        // Execute the action
+        if (action.kind === 'wake') {
+            if (this.handlers.onWake) {
+                try {
+                    await this.handlers.onWake({ text: action.text, mode: action.mode });
+                    this.sendJsonResponse(res, 200, { success: true });
+                }
+                catch (error) {
+                    console.error('[HooksServer] Wake handler error:', error);
+                    this.sendJsonResponse(res, 500, { success: false, error: String(error) });
+                }
+            }
+            else {
+                this.sendJsonResponse(res, 503, { success: false, error: 'Wake handler not configured' });
+            }
+        }
+        else if (action.kind === 'agent') {
+            if (this.handlers.onAgent) {
+                try {
+                    const result = await this.handlers.onAgent({
+                        message: action.message,
+                        name: action.name,
+                        wakeMode: action.wakeMode,
+                        sessionKey: action.sessionKey,
+                        deliver: action.deliver,
+                        channel: action.channel,
+                        to: action.to,
+                        model: action.model,
+                        thinking: action.thinking,
+                        timeoutSeconds: action.timeoutSeconds,
+                    });
+                    this.sendJsonResponse(res, 202, { success: true, taskId: result.taskId });
+                }
+                catch (error) {
+                    console.error('[HooksServer] Agent handler error:', error);
+                    this.sendJsonResponse(res, 500, { success: false, error: String(error) });
+                }
+            }
+            else {
+                this.sendJsonResponse(res, 503, { success: false, error: 'Agent handler not configured' });
+            }
+        }
+    }
+    /**
+     * Extract hook token from request
+     */
+    extractHookToken(req, url) {
+        // Check Authorization header
+        const auth = typeof req.headers.authorization === 'string' ? req.headers.authorization.trim() : '';
+        if (auth.toLowerCase().startsWith('bearer ')) {
+            const token = auth.slice(7).trim();
+            if (token)
+                return { token, fromQuery: false };
+        }
+        // Check X-CoWork-Token header
+        const headerToken = typeof req.headers['x-cowork-token'] === 'string'
+            ? req.headers['x-cowork-token'].trim()
+            : '';
+        if (headerToken)
+            return { token: headerToken, fromQuery: false };
+        // Check query param (deprecated)
+        const queryToken = url.searchParams.get('token');
+        if (queryToken)
+            return { token: queryToken.trim(), fromQuery: true };
+        return { token: undefined, fromQuery: false };
+    }
+    /**
+     * Verify the provided token
+     */
+    verifyToken(provided) {
+        if (!this.hooksConfig?.token)
+            return false;
+        if (!provided)
+            return false;
+        // Use timing-safe comparison
+        const expected = Buffer.from(this.hooksConfig.token);
+        const actual = Buffer.from(provided);
+        if (expected.length !== actual.length)
+            return false;
+        return crypto_1.default.timingSafeEqual(expected, actual);
+    }
+    /**
+     * Normalize request headers
+     */
+    normalizeHeaders(req) {
+        const headers = {};
+        for (const [key, value] of Object.entries(req.headers)) {
+            if (typeof value === 'string') {
+                headers[key.toLowerCase()] = value;
+            }
+            else if (Array.isArray(value) && value.length > 0) {
+                headers[key.toLowerCase()] = value.join(', ');
+            }
+        }
+        return headers;
+    }
+    /**
+     * Parse JSON body from request with timeout to prevent slow client DoS
+     */
+    parseJsonBody(req) {
+        const maxBytes = this.hooksConfig?.maxBodyBytes || types_1.DEFAULT_HOOKS_MAX_BODY_BYTES;
+        const REQUEST_TIMEOUT_MS = 30000; // 30 second timeout for request body
+        return new Promise((resolve) => {
+            let done = false;
+            let total = 0;
+            const chunks = [];
+            // Timeout to prevent slow client resource exhaustion
+            const timeout = setTimeout(() => {
+                if (done)
+                    return;
+                done = true;
+                console.warn('[HooksServer] Request body timeout - slow client detected');
+                resolve(null);
+                req.destroy();
+            }, REQUEST_TIMEOUT_MS);
+            const cleanup = () => {
+                clearTimeout(timeout);
+            };
+            req.on('data', (chunk) => {
+                if (done)
+                    return;
+                total += chunk.length;
+                if (total > maxBytes) {
+                    done = true;
+                    cleanup();
+                    resolve(null);
+                    req.destroy();
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            req.on('end', () => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                const raw = Buffer.concat(chunks).toString('utf-8').trim();
+                if (!raw) {
+                    resolve({});
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(raw));
+                }
+                catch {
+                    resolve(null);
+                }
+            });
+            req.on('error', () => {
+                if (done)
+                    return;
+                done = true;
+                cleanup();
+                resolve(null);
+            });
+        });
+    }
+    /**
+     * Send JSON response
+     */
+    sendJsonResponse(res, status, data) {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    }
+    /**
+     * Emit a server event
+     */
+    emitEvent(event) {
+        if (this.handlers.onEvent) {
+            try {
+                this.handlers.onEvent(event);
+            }
+            catch (error) {
+                console.error('[HooksServer] Event handler error:', error);
+            }
+        }
+    }
+}
+exports.HooksServer = HooksServer;