cowork-os 0.3.21

package/dist/electron/electron/guardrails/guardrail-manager.js

@@ -0,0 +1,348 @@
+"use strict";
+/**
+ * Guardrail Manager
+ *
+ * Manages user-configurable safety guardrails for the agent.
+ * Settings are stored encrypted in the database using SecureSettingsRepository.
+ */
+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.GuardrailManager = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../../shared/types");
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'guardrail-settings.json';
+const DEFAULT_SETTINGS = {
+    // Token Budget
+    maxTokensPerTask: 100000,
+    tokenBudgetEnabled: true,
+    // Cost Budget
+    maxCostPerTask: 1.00,
+    costBudgetEnabled: false,
+    // Dangerous Commands
+    blockDangerousCommands: true,
+    customBlockedPatterns: [],
+    // Auto-Approve Trusted Commands
+    autoApproveTrustedCommands: true, // Enabled by default for common safe commands
+    trustedCommandPatterns: [],
+    // File Size
+    maxFileSizeMB: 50,
+    fileSizeLimitEnabled: true,
+    // Network Domains
+    enforceAllowedDomains: false,
+    allowedDomains: [],
+    // Iterations
+    maxIterationsPerTask: 50,
+    iterationLimitEnabled: true,
+};
+class GuardrailManager {
+    /**
+     * Initialize the GuardrailManager
+     */
+    static initialize() {
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        // Migrate from legacy JSON file to encrypted database
+        this.migrateFromLegacyFile();
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                console.log('[GuardrailManager] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            if (repository.exists('guardrails')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[GuardrailManager] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[GuardrailManager] Migrating settings from legacy JSON file to encrypted database...');
+            // Create backup before migration
+            const backupPath = this.legacySettingsPath + '.migration-backup';
+            fs.copyFileSync(this.legacySettingsPath, backupPath);
+            try {
+                const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+                const legacySettings = { ...DEFAULT_SETTINGS, ...JSON.parse(data) };
+                repository.save('guardrails', legacySettings);
+                console.log('[GuardrailManager] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[GuardrailManager] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[GuardrailManager] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[GuardrailManager] Migration failed:', error);
+        }
+    }
+    /**
+     * Load settings from encrypted database (with caching)
+     */
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('guardrails');
+                if (stored) {
+                    this.cachedSettings = { ...DEFAULT_SETTINGS, ...stored };
+                    return this.cachedSettings;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[GuardrailManager] Failed to load settings:', error);
+        }
+        this.cachedSettings = { ...DEFAULT_SETTINGS };
+        return this.cachedSettings;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            repository.save('guardrails', settings);
+            this.cachedSettings = settings;
+            console.log('[GuardrailManager] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[GuardrailManager] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear the settings cache (call after external changes)
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get default settings (for reference)
+     */
+    static getDefaults() {
+        return { ...DEFAULT_SETTINGS };
+    }
+    /**
+     * Check if a command matches any blocked pattern
+     * @returns Object with blocked status and matched pattern if blocked
+     */
+    static isCommandBlocked(command) {
+        const settings = this.loadSettings();
+        if (!settings.blockDangerousCommands) {
+            return { blocked: false };
+        }
+        // Combine default patterns with custom patterns
+        const allPatterns = [
+            ...types_1.DEFAULT_BLOCKED_COMMAND_PATTERNS,
+            ...settings.customBlockedPatterns,
+        ];
+        for (const pattern of allPatterns) {
+            try {
+                // Try to compile as regex
+                const regex = new RegExp(pattern, 'i');
+                if (regex.test(command)) {
+                    return { blocked: true, pattern };
+                }
+            }
+            catch {
+                // If invalid regex, try simple case-insensitive substring match
+                if (command.toLowerCase().includes(pattern.toLowerCase())) {
+                    return { blocked: true, pattern };
+                }
+            }
+        }
+        return { blocked: false };
+    }
+    /**
+     * Convert a glob-like pattern to regex
+     * Supports * as wildcard for any characters
+     */
+    static globToRegex(pattern) {
+        // Escape special regex characters except *
+        const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+        // Convert * to regex wildcard (.*)
+        const regexStr = '^' + escaped.replace(/\*/g, '.*') + '$';
+        return new RegExp(regexStr, 'i');
+    }
+    /**
+     * Check if a command matches any trusted pattern (auto-approve without user confirmation)
+     * @returns Object with trusted status and matched pattern if trusted
+     */
+    static isCommandTrusted(command) {
+        const settings = this.loadSettings();
+        if (!settings.autoApproveTrustedCommands) {
+            return { trusted: false };
+        }
+        // Combine default patterns with custom patterns
+        const allPatterns = [
+            ...types_1.DEFAULT_TRUSTED_COMMAND_PATTERNS,
+            ...settings.trustedCommandPatterns,
+        ];
+        for (const pattern of allPatterns) {
+            try {
+                const regex = this.globToRegex(pattern);
+                if (regex.test(command)) {
+                    return { trusted: true, pattern };
+                }
+            }
+            catch {
+                // If conversion fails, try simple prefix match
+                const prefix = pattern.replace(/\*/g, '');
+                if (command.toLowerCase().startsWith(prefix.toLowerCase())) {
+                    return { trusted: true, pattern };
+                }
+            }
+        }
+        return { trusted: false };
+    }
+    /**
+     * Check if a URL's domain is allowed for network access
+     * @returns true if allowed, false if blocked
+     */
+    static isDomainAllowed(url) {
+        const settings = this.loadSettings();
+        // If domain enforcement is disabled, allow everything
+        if (!settings.enforceAllowedDomains) {
+            return true;
+        }
+        // If no domains configured, block everything (safety)
+        if (settings.allowedDomains.length === 0) {
+            return false;
+        }
+        try {
+            const parsedUrl = new URL(url);
+            const hostname = parsedUrl.hostname.toLowerCase();
+            return settings.allowedDomains.some(pattern => {
+                const normalizedPattern = pattern.toLowerCase().trim();
+                if (normalizedPattern.startsWith('*.')) {
+                    // Wildcard match (e.g., *.google.com matches maps.google.com)
+                    const suffix = normalizedPattern.slice(2);
+                    return hostname === suffix || hostname.endsWith('.' + suffix);
+                }
+                // Exact match
+                return hostname === normalizedPattern;
+            });
+        }
+        catch {
+            // Invalid URL - block it
+            return false;
+        }
+    }
+    /**
+     * Check if file size exceeds the limit
+     * @param sizeInBytes Size of the content in bytes
+     * @returns Object with exceeded status and limit info
+     */
+    static isFileSizeExceeded(sizeInBytes) {
+        const settings = this.loadSettings();
+        const sizeMB = sizeInBytes / (1024 * 1024);
+        if (!settings.fileSizeLimitEnabled) {
+            return { exceeded: false, sizeMB, limitMB: settings.maxFileSizeMB };
+        }
+        return {
+            exceeded: sizeMB > settings.maxFileSizeMB,
+            sizeMB,
+            limitMB: settings.maxFileSizeMB,
+        };
+    }
+    /**
+     * Check if token budget is exceeded
+     */
+    static isTokenBudgetExceeded(tokensUsed) {
+        const settings = this.loadSettings();
+        if (!settings.tokenBudgetEnabled) {
+            return { exceeded: false, used: tokensUsed, limit: settings.maxTokensPerTask };
+        }
+        return {
+            exceeded: tokensUsed >= settings.maxTokensPerTask,
+            used: tokensUsed,
+            limit: settings.maxTokensPerTask,
+        };
+    }
+    /**
+     * Check if cost budget is exceeded
+     */
+    static isCostBudgetExceeded(costIncurred) {
+        const settings = this.loadSettings();
+        if (!settings.costBudgetEnabled) {
+            return { exceeded: false, cost: costIncurred, limit: settings.maxCostPerTask };
+        }
+        return {
+            exceeded: costIncurred >= settings.maxCostPerTask,
+            cost: costIncurred,
+            limit: settings.maxCostPerTask,
+        };
+    }
+    /**
+     * Check if iteration limit is exceeded
+     */
+    static isIterationLimitExceeded(iterations) {
+        const settings = this.loadSettings();
+        if (!settings.iterationLimitEnabled) {
+            return { exceeded: false, iterations, limit: settings.maxIterationsPerTask };
+        }
+        return {
+            exceeded: iterations >= settings.maxIterationsPerTask,
+            iterations,
+            limit: settings.maxIterationsPerTask,
+        };
+    }
+}
+exports.GuardrailManager = GuardrailManager;
+GuardrailManager.cachedSettings = null;
+GuardrailManager.migrationCompleted = false;

package/dist/electron/electron/hooks/gmail-watcher.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * Gmail Watcher Service
+ *
+ * Automatically starts Gmail watch when the app starts,
+ * if hooks.gmail is configured with an account.
+ *
+ * This requires 'gog' (gogcli) to be installed and configured.
+ * See: https://gogcli.sh/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isGogAvailable = isGogAvailable;
+exports.resolveGmailRuntimeConfig = resolveGmailRuntimeConfig;
+exports.startGmailWatcher = startGmailWatcher;
+exports.stopGmailWatcher = stopGmailWatcher;
+exports.isGmailWatcherRunning = isGmailWatcherRunning;
+exports.getGmailRuntimeConfig = getGmailRuntimeConfig;
+const child_process_1 = require("child_process");
+const process_1 = require("../utils/process");
+const ADDRESS_IN_USE_RE = /address already in use|EADDRINUSE/i;
+let watcherProcess = null;
+let renewInterval = null;
+let shuttingDown = false;
+let currentConfig = null;
+/**
+ * Check if gog binary is available
+ */
+async function isGogAvailable() {
+    return (0, process_1.checkBinaryExists)('gog');
+}
+/**
+ * Resolve Gmail runtime configuration from hooks config
+ */
+function resolveGmailRuntimeConfig(config) {
+    const hooks = config;
+    const gmail = hooks.gmail;
+    const hookToken = hooks.token?.trim();
+    if (!hookToken) {
+        return { ok: false, error: 'hooks.token missing (needed for gmail hook)' };
+    }
+    const account = gmail?.account?.trim();
+    if (!account) {
+        return { ok: false, error: 'gmail account required' };
+    }
+    const topic = gmail?.topic?.trim();
+    if (!topic) {
+        return { ok: false, error: 'gmail topic required' };
+    }
+    const pushToken = gmail?.pushToken?.trim();
+    if (!pushToken) {
+        return { ok: false, error: 'gmail push token required' };
+    }
+    const subscription = gmail?.subscription || 'cowork-gmail-watch-push';
+    const label = gmail?.label || 'INBOX';
+    const hookUrl = gmail?.hookUrl || 'http://127.0.0.1:9877/hooks/gmail';
+    const includeBody = gmail?.includeBody ?? true;
+    const maxBytes = gmail?.maxBytes || 20000;
+    const renewEveryMinutes = gmail?.renewEveryMinutes || 12 * 60;
+    const serveBind = gmail?.serve?.bind || '127.0.0.1';
+    const servePort = gmail?.serve?.port || 8788;
+    const servePath = gmail?.serve?.path || '/gmail-pubsub';
+    const tailscaleMode = gmail?.tailscale?.mode || 'off';
+    const tailscalePath = gmail?.tailscale?.path || servePath;
+    const tailscaleTarget = gmail?.tailscale?.target;
+    return {
+        ok: true,
+        value: {
+            account,
+            label,
+            topic,
+            subscription,
+            pushToken,
+            hookToken,
+            hookUrl,
+            includeBody,
+            maxBytes,
+            renewEveryMinutes,
+            serve: {
+                bind: serveBind,
+                port: servePort,
+                path: servePath,
+            },
+            tailscale: {
+                mode: tailscaleMode,
+                path: tailscalePath,
+                target: tailscaleTarget,
+            },
+        },
+    };
+}
+/**
+ * Build gog watch start arguments
+ */
+function buildWatchStartArgs(cfg) {
+    return [
+        'gmail',
+        'watch',
+        'start',
+        '--account',
+        cfg.account,
+        '--label',
+        cfg.label,
+        '--topic',
+        cfg.topic,
+    ];
+}
+/**
+ * Build gog watch serve arguments
+ */
+function buildWatchServeArgs(cfg) {
+    const args = [
+        'gmail',
+        'watch',
+        'serve',
+        '--account',
+        cfg.account,
+        '--bind',
+        cfg.serve.bind,
+        '--port',
+        String(cfg.serve.port),
+        '--path',
+        cfg.serve.path,
+        '--token',
+        cfg.pushToken,
+        '--hook-url',
+        cfg.hookUrl,
+        '--hook-token',
+        cfg.hookToken,
+    ];
+    if (cfg.includeBody) {
+        args.push('--include-body');
+    }
+    if (cfg.maxBytes > 0) {
+        args.push('--max-bytes', String(cfg.maxBytes));
+    }
+    return args;
+}
+/**
+ * Start the Gmail watch (registers with Gmail API)
+ */
+async function startGmailWatch(cfg) {
+    const args = buildWatchStartArgs(cfg);
+    console.log(`[GmailWatcher] Starting watch: gog ${args.join(' ')}`);
+    try {
+        const result = await (0, process_1.runCommand)('gog', args, { timeoutMs: 120000 });
+        if (result.code !== 0) {
+            const message = result.stderr || result.stdout || 'gog watch start failed';
+            console.error(`[GmailWatcher] Watch start failed: ${message}`);
+            return false;
+        }
+        console.log(`[GmailWatcher] Watch started for ${cfg.account}`);
+        return true;
+    }
+    catch (err) {
+        console.error(`[GmailWatcher] Watch start error: ${String(err)}`);
+        return false;
+    }
+}
+/**
+ * Spawn the gog gmail watch serve process
+ */
+function spawnGogServe(cfg) {
+    const args = buildWatchServeArgs(cfg);
+    console.log(`[GmailWatcher] Starting serve: gog ${args.join(' ')}`);
+    let addressInUse = false;
+    const child = (0, child_process_1.spawn)('gog', args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        detached: false,
+    });
+    child.stdout?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (line)
+            console.log(`[GmailWatcher] [gog] ${line}`);
+    });
+    child.stderr?.on('data', (data) => {
+        const line = data.toString().trim();
+        if (!line)
+            return;
+        if (ADDRESS_IN_USE_RE.test(line)) {
+            addressInUse = true;
+        }
+        console.warn(`[GmailWatcher] [gog] ${line}`);
+    });
+    child.on('error', (err) => {
+        console.error(`[GmailWatcher] gog process error: ${String(err)}`);
+    });
+    child.on('exit', (code, signal) => {
+        if (shuttingDown)
+            return;
+        if (addressInUse) {
+            console.warn('[GmailWatcher] gog serve failed to bind (address already in use); stopping restarts. ' +
+                'Another watcher is likely running.');
+            watcherProcess = null;
+            return;
+        }
+        console.warn(`[GmailWatcher] gog exited (code=${code}, signal=${signal}); restarting in 5s`);
+        watcherProcess = null;
+        setTimeout(() => {
+            if (shuttingDown || !currentConfig)
+                return;
+            watcherProcess = spawnGogServe(currentConfig);
+        }, 5000);
+    });
+    return child;
+}
+/**
+ * Start the Gmail watcher service.
+ * Called automatically by the app if hooks.gmail is configured.
+ */
+async function startGmailWatcher(config) {
+    // Check if gmail hooks are configured
+    if (!config.enabled) {
+        return { started: false, reason: 'hooks not enabled' };
+    }
+    if (!config.gmail?.account) {
+        return { started: false, reason: 'no gmail account configured' };
+    }
+    // Check if gog is available
+    const gogAvailable = await isGogAvailable();
+    if (!gogAvailable) {
+        return { started: false, reason: 'gog binary not found (install from gogcli.sh)' };
+    }
+    // Resolve the full runtime config
+    const resolved = resolveGmailRuntimeConfig(config);
+    if (!resolved.ok) {
+        return { started: false, reason: resolved.error };
+    }
+    const runtimeConfig = resolved.value;
+    // Check if watcher is already running
+    if (watcherProcess && currentConfig) {
+        // If same account, already running
+        if (currentConfig.account === runtimeConfig.account) {
+            console.log(`[GmailWatcher] Already running for ${runtimeConfig.account}`);
+            return { started: true };
+        }
+        // Different account - stop the old watcher first
+        console.log(`[GmailWatcher] Switching from ${currentConfig.account} to ${runtimeConfig.account}`);
+        await stopGmailWatcher();
+    }
+    currentConfig = runtimeConfig;
+    // Start the Gmail watch (register with Gmail API)
+    const watchStarted = await startGmailWatch(runtimeConfig);
+    if (!watchStarted) {
+        console.warn('[GmailWatcher] Gmail watch start failed, but continuing with serve');
+    }
+    // Spawn the gog serve process
+    shuttingDown = false;
+    watcherProcess = spawnGogServe(runtimeConfig);
+    // Set up renewal interval
+    const renewMs = runtimeConfig.renewEveryMinutes * 60000;
+    renewInterval = setInterval(() => {
+        if (shuttingDown)
+            return;
+        void startGmailWatch(runtimeConfig);
+    }, renewMs);
+    console.log(`[GmailWatcher] Gmail watcher started for ${runtimeConfig.account} (renew every ${runtimeConfig.renewEveryMinutes}m)`);
+    return { started: true };
+}
+/**
+ * Stop the Gmail watcher service.
+ */
+async function stopGmailWatcher() {
+    shuttingDown = true;
+    if (renewInterval) {
+        clearInterval(renewInterval);
+        renewInterval = null;
+    }
+    if (watcherProcess) {
+        console.log('[GmailWatcher] Stopping Gmail watcher');
+        watcherProcess.kill('SIGTERM');
+        // Wait a bit for graceful shutdown
+        await new Promise((resolve) => {
+            const timeout = setTimeout(() => {
+                if (watcherProcess) {
+                    watcherProcess.kill('SIGKILL');
+                }
+                resolve();
+            }, 3000);
+            watcherProcess?.on('exit', () => {
+                clearTimeout(timeout);
+                resolve();
+            });
+        });
+        watcherProcess = null;
+    }
+    currentConfig = null;
+    console.log('[GmailWatcher] Gmail watcher stopped');
+}
+/**
+ * Check if the Gmail watcher is running.
+ */
+function isGmailWatcherRunning() {
+    return watcherProcess !== null && !shuttingDown;
+}
+/**
+ * Get the current Gmail runtime config (if running)
+ */
+function getGmailRuntimeConfig() {
+    return currentConfig;
+}

package/dist/electron/electron/hooks/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Hooks Module
+ *
+ * Webhook ingress for wake and isolated agent runs.
+ * Includes Gmail Pub/Sub integration.
+ */
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGmailRuntimeConfig = exports.resolveGmailRuntimeConfig = exports.isGogAvailable = exports.isGmailWatcherRunning = exports.stopGmailWatcher = exports.startGmailWatcher = exports.resolveHooksConfig = exports.HooksServer = exports.normalizeHooksPath = exports.applyHookMappings = exports.resolveHookMappings = exports.generateHookToken = exports.HooksSettingsManager = void 0;
+// Types
+__exportStar(require("./types"), exports);
+// Settings Manager
+var settings_1 = require("./settings");
+Object.defineProperty(exports, "HooksSettingsManager", { enumerable: true, get: function () { return settings_1.HooksSettingsManager; } });
+Object.defineProperty(exports, "generateHookToken", { enumerable: true, get: function () { return settings_1.generateHookToken; } });
+// Hook Mappings
+var mappings_1 = require("./mappings");
+Object.defineProperty(exports, "resolveHookMappings", { enumerable: true, get: function () { return mappings_1.resolveHookMappings; } });
+Object.defineProperty(exports, "applyHookMappings", { enumerable: true, get: function () { return mappings_1.applyHookMappings; } });
+Object.defineProperty(exports, "normalizeHooksPath", { enumerable: true, get: function () { return mappings_1.normalizeHooksPath; } });
+// Webhook Server
+var server_1 = require("./server");
+Object.defineProperty(exports, "HooksServer", { enumerable: true, get: function () { return server_1.HooksServer; } });
+Object.defineProperty(exports, "resolveHooksConfig", { enumerable: true, get: function () { return server_1.resolveHooksConfig; } });
+// Gmail Watcher
+var gmail_watcher_1 = require("./gmail-watcher");
+Object.defineProperty(exports, "startGmailWatcher", { enumerable: true, get: function () { return gmail_watcher_1.startGmailWatcher; } });
+Object.defineProperty(exports, "stopGmailWatcher", { enumerable: true, get: function () { return gmail_watcher_1.stopGmailWatcher; } });
+Object.defineProperty(exports, "isGmailWatcherRunning", { enumerable: true, get: function () { return gmail_watcher_1.isGmailWatcherRunning; } });
+Object.defineProperty(exports, "isGogAvailable", { enumerable: true, get: function () { return gmail_watcher_1.isGogAvailable; } });
+Object.defineProperty(exports, "resolveGmailRuntimeConfig", { enumerable: true, get: function () { return gmail_watcher_1.resolveGmailRuntimeConfig; } });
+Object.defineProperty(exports, "getGmailRuntimeConfig", { enumerable: true, get: function () { return gmail_watcher_1.getGmailRuntimeConfig; } });