cowork-os 0.3.21

package/dist/electron/electron/hooks/settings.js

@@ -0,0 +1,447 @@
+"use strict";
+/**
+ * Hooks Settings Manager
+ *
+ * Manages webhook configuration with encrypted storage.
+ * 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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HooksSettingsManager = void 0;
+exports.generateHookToken = generateHookToken;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto_1 = __importDefault(require("crypto"));
+const types_1 = require("./types");
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'hooks-settings.json';
+const MASKED_VALUE = '***configured***';
+const ENCRYPTED_PREFIX = 'encrypted:';
+/**
+ * Generate a secure random token
+ */
+function generateHookToken(bytes = 24) {
+    return crypto_1.default.randomBytes(bytes).toString('hex');
+}
+/**
+ * Encrypt a secret using OS keychain via safeStorage
+ */
+function encryptSecret(value) {
+    if (!value || !value.trim())
+        return undefined;
+    const trimmed = value.trim();
+    if (trimmed === MASKED_VALUE)
+        return undefined;
+    try {
+        if (electron_1.safeStorage.isEncryptionAvailable()) {
+            const encrypted = electron_1.safeStorage.encryptString(trimmed);
+            return ENCRYPTED_PREFIX + encrypted.toString('base64');
+        }
+    }
+    catch (error) {
+        console.warn('[Hooks Settings] Failed to encrypt secret, storing masked:', error);
+    }
+    // Fallback to masked value if encryption fails
+    return MASKED_VALUE;
+}
+/**
+ * Decrypt a secret that was encrypted with safeStorage
+ */
+function decryptSecret(value) {
+    if (!value)
+        return undefined;
+    if (value === MASKED_VALUE)
+        return undefined;
+    if (value.startsWith(ENCRYPTED_PREFIX)) {
+        try {
+            if (electron_1.safeStorage.isEncryptionAvailable()) {
+                const encrypted = Buffer.from(value.slice(ENCRYPTED_PREFIX.length), 'base64');
+                const decrypted = electron_1.safeStorage.decryptString(encrypted);
+                return decrypted;
+            }
+            else {
+                console.error('[Hooks Settings] safeStorage encryption not available - cannot decrypt secrets');
+            }
+        }
+        catch (error) {
+            console.error('[Hooks Settings] Failed to decrypt secret:', error.message || error);
+        }
+    }
+    // If not encrypted and not masked, return as-is (for backwards compatibility)
+    if (value !== MASKED_VALUE && !value.startsWith(ENCRYPTED_PREFIX)) {
+        return value.trim() || undefined;
+    }
+    return undefined;
+}
+/**
+ * Encrypt all credentials in settings before saving to disk
+ */
+function encryptSettings(settings) {
+    return {
+        ...settings,
+        token: encryptSecret(settings.token) || '',
+        gmail: settings.gmail ? {
+            ...settings.gmail,
+            pushToken: encryptSecret(settings.gmail.pushToken),
+        } : undefined,
+    };
+}
+/**
+ * Decrypt all credentials in settings after loading from disk
+ */
+function decryptSettings(settings) {
+    return {
+        ...settings,
+        token: decryptSecret(settings.token) || '',
+        gmail: settings.gmail ? {
+            ...settings.gmail,
+            pushToken: decryptSecret(settings.gmail.pushToken),
+        } : undefined,
+    };
+}
+/**
+ * Hooks Settings Manager
+ */
+class HooksSettingsManager {
+    /**
+     * Initialize the settings manager (must be called after app is ready)
+     */
+    static initialize() {
+        if (this.initialized)
+            return;
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        this.initialized = true;
+        console.log('[Hooks Settings] Initialized');
+        // 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('[Hooks Settings] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            if (repository.exists('hooks')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[Hooks Settings] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[Hooks Settings] 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 parsed = JSON.parse(data);
+                const merged = {
+                    ...types_1.DEFAULT_HOOKS_CONFIG,
+                    ...parsed,
+                    mappings: parsed.mappings || [],
+                    presets: parsed.presets || [],
+                };
+                // Decrypt any existing encrypted values before saving to the new encrypted database
+                const decrypted = decryptSettings(merged);
+                repository.save('hooks', decrypted);
+                console.log('[Hooks Settings] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[Hooks Settings] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[Hooks Settings] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[Hooks Settings] Migration failed:', error);
+        }
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    static loadSettings() {
+        this.ensureInitialized();
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('hooks');
+                if (stored) {
+                    const merged = {
+                        ...types_1.DEFAULT_HOOKS_CONFIG,
+                        ...stored,
+                        mappings: stored.mappings || [],
+                        presets: stored.presets || [],
+                    };
+                    this.cachedSettings = merged;
+                    console.log('[Hooks Settings] Loaded settings from encrypted database');
+                    return this.cachedSettings;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[Hooks Settings] Failed to load settings:', error);
+        }
+        console.log('[Hooks Settings] No settings found, using defaults');
+        this.cachedSettings = { ...types_1.DEFAULT_HOOKS_CONFIG };
+        return this.cachedSettings;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        this.ensureInitialized();
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            repository.save('hooks', settings);
+            this.cachedSettings = settings;
+            console.log('[Hooks Settings] Saved settings to encrypted database');
+        }
+        catch (error) {
+            console.error('[Hooks Settings] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear the settings cache (forces reload on next access)
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get default settings
+     */
+    static getDefaults() {
+        return { ...types_1.DEFAULT_HOOKS_CONFIG };
+    }
+    /**
+     * Update hooks configuration
+     */
+    static updateConfig(updates) {
+        const settings = this.loadSettings();
+        const updated = { ...settings, ...updates };
+        this.saveSettings(updated);
+        return updated;
+    }
+    /**
+     * Enable hooks with a new token if not already configured
+     */
+    static enableHooks() {
+        const settings = this.loadSettings();
+        if (!settings.token) {
+            settings.token = generateHookToken();
+        }
+        settings.enabled = true;
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Disable hooks
+     */
+    static disableHooks() {
+        const settings = this.loadSettings();
+        settings.enabled = false;
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Regenerate the hook token
+     */
+    static regenerateToken() {
+        const settings = this.loadSettings();
+        settings.token = generateHookToken();
+        this.saveSettings(settings);
+        return settings.token;
+    }
+    /**
+     * Add or update a preset
+     */
+    static addPreset(preset) {
+        const settings = this.loadSettings();
+        const presets = new Set(settings.presets);
+        presets.add(preset);
+        settings.presets = Array.from(presets);
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Remove a preset
+     */
+    static removePreset(preset) {
+        const settings = this.loadSettings();
+        settings.presets = settings.presets.filter((p) => p !== preset);
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Add a custom mapping
+     */
+    static addMapping(mapping) {
+        const settings = this.loadSettings();
+        settings.mappings.push(mapping);
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Update a mapping by ID
+     */
+    static updateMapping(id, updates) {
+        const settings = this.loadSettings();
+        const index = settings.mappings.findIndex((m) => m.id === id);
+        if (index === -1)
+            return null;
+        settings.mappings[index] = { ...settings.mappings[index], ...updates };
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Remove a mapping by ID
+     */
+    static removeMapping(id) {
+        const settings = this.loadSettings();
+        settings.mappings = settings.mappings.filter((m) => m.id !== id);
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Configure Gmail hooks
+     */
+    static configureGmail(gmailConfig) {
+        const settings = this.loadSettings();
+        settings.gmail = {
+            ...settings.gmail,
+            ...gmailConfig,
+        };
+        // Auto-add gmail preset if account is configured
+        if (gmailConfig.account && !settings.presets.includes('gmail')) {
+            settings.presets.push('gmail');
+        }
+        this.saveSettings(settings);
+        return settings;
+    }
+    /**
+     * Get Gmail configuration with defaults filled in
+     */
+    static getGmailConfig() {
+        const settings = this.loadSettings();
+        const gmail = settings.gmail || {};
+        return {
+            account: gmail.account,
+            label: gmail.label || types_1.DEFAULT_GMAIL_LABEL,
+            topic: gmail.topic || types_1.DEFAULT_GMAIL_TOPIC,
+            subscription: gmail.subscription || types_1.DEFAULT_GMAIL_SUBSCRIPTION,
+            pushToken: gmail.pushToken,
+            hookUrl: gmail.hookUrl,
+            includeBody: gmail.includeBody ?? true,
+            maxBytes: gmail.maxBytes || types_1.DEFAULT_GMAIL_MAX_BYTES,
+            renewEveryMinutes: gmail.renewEveryMinutes || types_1.DEFAULT_GMAIL_RENEW_MINUTES,
+            model: gmail.model,
+            thinking: gmail.thinking,
+            allowUnsafeExternalContent: gmail.allowUnsafeExternalContent,
+            serve: {
+                bind: gmail.serve?.bind || types_1.DEFAULT_GMAIL_SERVE_BIND,
+                port: gmail.serve?.port || types_1.DEFAULT_GMAIL_SERVE_PORT,
+                path: gmail.serve?.path || types_1.DEFAULT_GMAIL_SERVE_PATH,
+            },
+            tailscale: {
+                mode: gmail.tailscale?.mode || 'off',
+                path: gmail.tailscale?.path || types_1.DEFAULT_GMAIL_SERVE_PATH,
+                target: gmail.tailscale?.target,
+            },
+        };
+    }
+    /**
+     * Get settings for UI display (masks sensitive data)
+     */
+    static getSettingsForDisplay() {
+        const settings = this.loadSettings();
+        return {
+            ...settings,
+            token: settings.token ? MASKED_VALUE : '',
+            gmail: settings.gmail ? {
+                ...settings.gmail,
+                pushToken: settings.gmail.pushToken ? MASKED_VALUE : undefined,
+            } : undefined,
+        };
+    }
+    /**
+     * Check if hooks are properly configured
+     */
+    static isConfigured() {
+        const settings = this.loadSettings();
+        return settings.enabled && !!settings.token;
+    }
+    /**
+     * Check if Gmail hooks are configured
+     */
+    static isGmailConfigured() {
+        const settings = this.loadSettings();
+        return !!(settings.gmail?.account && settings.gmail?.topic && settings.gmail?.pushToken);
+    }
+    /**
+     * Ensure the manager is initialized
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            this.initialize();
+        }
+    }
+}
+exports.HooksSettingsManager = HooksSettingsManager;
+HooksSettingsManager.cachedSettings = null;
+HooksSettingsManager.initialized = false;
+HooksSettingsManager.migrationCompleted = false;

package/dist/electron/electron/hooks/types.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Hooks Configuration Types
+ *
+ * Webhook ingress for wake and isolated agent runs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOOK_PRESET_MAPPINGS = exports.GMAIL_PRESET_MAPPING = exports.DEFAULT_HOOKS_CONFIG = exports.DEFAULT_GMAIL_RENEW_MINUTES = exports.DEFAULT_GMAIL_MAX_BYTES = exports.DEFAULT_GMAIL_SERVE_PATH = exports.DEFAULT_GMAIL_SERVE_PORT = exports.DEFAULT_GMAIL_SERVE_BIND = exports.DEFAULT_GMAIL_SUBSCRIPTION = exports.DEFAULT_GMAIL_TOPIC = exports.DEFAULT_GMAIL_LABEL = exports.DEFAULT_HOOKS_PORT = exports.DEFAULT_HOOKS_MAX_BODY_BYTES = exports.DEFAULT_HOOKS_PATH = void 0;
+// ============ Default Values ============
+exports.DEFAULT_HOOKS_PATH = '/hooks';
+exports.DEFAULT_HOOKS_MAX_BODY_BYTES = 256 * 1024; // 256KB
+exports.DEFAULT_HOOKS_PORT = 9877;
+exports.DEFAULT_GMAIL_LABEL = 'INBOX';
+exports.DEFAULT_GMAIL_TOPIC = 'cowork-gmail-watch';
+exports.DEFAULT_GMAIL_SUBSCRIPTION = 'cowork-gmail-watch-push';
+exports.DEFAULT_GMAIL_SERVE_BIND = '127.0.0.1';
+exports.DEFAULT_GMAIL_SERVE_PORT = 8788;
+exports.DEFAULT_GMAIL_SERVE_PATH = '/gmail-pubsub';
+exports.DEFAULT_GMAIL_MAX_BYTES = 20000;
+exports.DEFAULT_GMAIL_RENEW_MINUTES = 12 * 60; // 12 hours
+exports.DEFAULT_HOOKS_CONFIG = {
+    enabled: false,
+    token: '',
+    path: exports.DEFAULT_HOOKS_PATH,
+    maxBodyBytes: exports.DEFAULT_HOOKS_MAX_BODY_BYTES,
+    presets: [],
+    mappings: [],
+};
+// ============ Gmail Preset Mapping ============
+exports.GMAIL_PRESET_MAPPING = {
+    id: 'gmail',
+    match: { path: 'gmail' },
+    action: 'agent',
+    wakeMode: 'now',
+    name: 'Gmail',
+    sessionKey: 'hook:gmail:{{messages[0].id}}',
+    messageTemplate: 'New email from {{messages[0].from}}\nSubject: {{messages[0].subject}}\n{{messages[0].snippet}}\n{{messages[0].body}}',
+};
+exports.HOOK_PRESET_MAPPINGS = {
+    gmail: [exports.GMAIL_PRESET_MAPPING],
+};

package/dist/electron/electron/ipc/canvas-handlers.js

@@ -0,0 +1,158 @@
+"use strict";
+/**
+ * Canvas IPC Handlers
+ *
+ * IPC handlers for Live Canvas operations.
+ * These handlers bridge the renderer process with the CanvasManager.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupCanvasHandlers = setupCanvasHandlers;
+exports.cleanupCanvasHandlers = cleanupCanvasHandlers;
+const electron_1 = require("electron");
+const types_1 = require("../../shared/types");
+const canvas_manager_1 = require("../canvas/canvas-manager");
+/**
+ * Setup Canvas IPC handlers
+ */
+function setupCanvasHandlers(mainWindow, agentDaemon) {
+    const manager = canvas_manager_1.CanvasManager.getInstance();
+    // Set main window reference for event broadcasting
+    manager.setMainWindow(mainWindow);
+    // Set A2UI callback to forward actions to the agent
+    manager.setA2UICallback((action) => {
+        // Find the task associated with this session
+        const session = manager.getSession(action.sessionId);
+        if (session) {
+            // Format as user message and send to the running task
+            const message = formatA2UIMessage(action);
+            agentDaemon.sendMessage(session.taskId, message).catch((err) => {
+                console.error('[CanvasHandlers] Failed to send A2UI action to task:', err);
+            });
+        }
+    });
+    // Create a new canvas session
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_CREATE, async (_, data) => {
+        return manager.createSession(data.taskId, data.workspaceId, data.title);
+    });
+    // Get a canvas session by ID
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_GET_SESSION, async (_, sessionId) => {
+        return manager.getSession(sessionId) || null;
+    });
+    // List all canvas sessions (optionally filtered by taskId)
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_LIST_SESSIONS, async (_, taskId) => {
+        if (taskId) {
+            return manager.listSessionsForTask(taskId);
+        }
+        return manager.listAllSessions();
+    });
+    // Show a canvas window
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_SHOW, async (_, sessionId) => {
+        await manager.showCanvas(sessionId);
+        return { success: true };
+    });
+    // Hide a canvas window
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_HIDE, async (_, sessionId) => {
+        manager.hideCanvas(sessionId);
+        return { success: true };
+    });
+    // Close a canvas session
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_CLOSE, async (_, sessionId) => {
+        await manager.closeSession(sessionId);
+        return { success: true };
+    });
+    // Push content to a canvas
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_PUSH, async (_, data) => {
+        await manager.pushContent(data.sessionId, data.content, data.filename);
+        return { success: true };
+    });
+    // Execute script in canvas context
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_EVAL, async (_, data) => {
+        const result = await manager.evalScript(data.sessionId, data.script);
+        return { result };
+    });
+    // Take a snapshot of the canvas
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_SNAPSHOT, async (_, sessionId) => {
+        return manager.takeSnapshot(sessionId);
+    });
+    // Export canvas as HTML
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_EXPORT_HTML, async (_, sessionId) => {
+        return manager.exportAsHTML(sessionId);
+    });
+    // Export canvas to folder
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_EXPORT_TO_FOLDER, async (_, data) => {
+        return manager.exportToFolder(data.sessionId, data.targetDir);
+    });
+    // Open canvas in browser
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_OPEN_IN_BROWSER, async (_, sessionId) => {
+        return manager.openInBrowser(sessionId);
+    });
+    // Get session directory
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.CANVAS_GET_SESSION_DIR, async (_, sessionId) => {
+        return manager.getSessionDir(sessionId);
+    });
+    // Handle A2UI action from canvas window (internal IPC from canvas preload)
+    electron_1.ipcMain.handle('canvas:a2ui-action-from-window', async (event, action) => {
+        const window = electron_1.BrowserWindow.fromWebContents(event.sender);
+        if (window) {
+            manager.handleA2UIAction(window.id, action);
+        }
+        return { success: true };
+    });
+    // Get session info from canvas window (internal IPC from canvas preload)
+    electron_1.ipcMain.handle('canvas:get-session-from-window', async (event) => {
+        const window = electron_1.BrowserWindow.fromWebContents(event.sender);
+        if (!window)
+            return null;
+        const sessionId = manager.getSessionFromWindow(window);
+        if (!sessionId)
+            return null;
+        const session = manager.getSession(sessionId);
+        if (!session)
+            return null;
+        return {
+            id: session.id,
+            taskId: session.taskId,
+            workspaceId: session.workspaceId,
+            title: session.title,
+        };
+    });
+    // Request snapshot from canvas window (internal IPC from canvas preload)
+    electron_1.ipcMain.handle('canvas:request-snapshot-from-window', async (event) => {
+        const window = electron_1.BrowserWindow.fromWebContents(event.sender);
+        if (!window)
+            return null;
+        const sessionId = manager.getSessionFromWindow(window);
+        if (!sessionId)
+            return null;
+        return manager.takeSnapshot(sessionId);
+    });
+    // Log from canvas window (internal IPC from canvas preload)
+    electron_1.ipcMain.on('canvas:log', (event, data) => {
+        const window = electron_1.BrowserWindow.fromWebContents(event.sender);
+        const sessionId = window ? manager.getSessionFromWindow(window) : 'unknown';
+        console.log(`[Canvas:${sessionId?.slice(0, 8)}] ${data.message}`, data.data || '');
+    });
+    console.log('[CanvasHandlers] Canvas IPC handlers registered');
+}
+/**
+ * Format A2UI action as a message for the agent
+ */
+function formatA2UIMessage(action) {
+    let message = `[Canvas Interaction]\n`;
+    message += `Action: ${action.actionName}\n`;
+    if (action.componentId) {
+        message += `Component: ${action.componentId}\n`;
+    }
+    if (action.context && Object.keys(action.context).length > 0) {
+        message += `Context: ${JSON.stringify(action.context, null, 2)}\n`;
+    }
+    message += `\nThe user interacted with the canvas. Please respond appropriately based on this action.`;
+    return message;
+}
+/**
+ * Cleanup canvas handlers (call on app quit)
+ */
+async function cleanupCanvasHandlers() {
+    const manager = canvas_manager_1.CanvasManager.getInstance();
+    await manager.cleanup();
+}