cowork-os 0.3.21

package/dist/electron/electron/extensions/registry.js

@@ -0,0 +1,485 @@
+"use strict";
+/**
+ * Plugin Registry
+ *
+ * Central registry for managing loaded plugins.
+ * Handles plugin lifecycle, configuration, and event dispatch.
+ */
+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.getPluginRegistry = exports.PluginRegistry = void 0;
+const events_1 = require("events");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const loader_1 = require("./loader");
+// Package version (will be replaced at build time or read from package.json)
+const COWORK_VERSION = process.env.npm_package_version || '0.3.0';
+/**
+ * Plugin Registry - Singleton manager for all plugins
+ */
+class PluginRegistry extends events_1.EventEmitter {
+    constructor() {
+        super();
+        /** Loaded plugins by name */
+        this.plugins = new Map();
+        /** Registered channel adapters by plugin name */
+        this.channelAdapters = new Map();
+        /** Registered tools by name */
+        this.tools = new Map();
+        /** Plugin configurations */
+        this.configs = new Map();
+        /** Event handlers by plugin */
+        this.pluginEventHandlers = new Map();
+        /** Whether the registry has been initialized */
+        this.initialized = false;
+    }
+    /**
+     * Get the singleton instance
+     */
+    static getInstance() {
+        if (!PluginRegistry.instance) {
+            PluginRegistry.instance = new PluginRegistry();
+        }
+        return PluginRegistry.instance;
+    }
+    /**
+     * Initialize the registry and load all plugins
+     */
+    async initialize(extensionDirs) {
+        if (this.initialized) {
+            return;
+        }
+        console.log('Initializing plugin registry...');
+        // Discover plugins
+        const discovered = await (0, loader_1.discoverPlugins)(extensionDirs);
+        console.log(`Discovered ${discovered.length} plugins`);
+        // Load and register each plugin
+        for (const { path: pluginPath, manifest } of discovered) {
+            await this.loadAndRegister(pluginPath, manifest);
+        }
+        this.initialized = true;
+        console.log(`Plugin registry initialized with ${this.plugins.size} plugins`);
+    }
+    /**
+     * Load and register a single plugin
+     */
+    async loadAndRegister(pluginPath, manifest) {
+        const pluginName = manifest.name;
+        // Check compatibility
+        if (!(0, loader_1.isPluginCompatible)(manifest, COWORK_VERSION)) {
+            console.warn(`Plugin ${pluginName} requires CoWork ${manifest.coworkVersion}, skipping`);
+            return;
+        }
+        // Check if already loaded
+        if (this.plugins.has(pluginName)) {
+            console.warn(`Plugin ${pluginName} already loaded, skipping`);
+            return;
+        }
+        try {
+            // Load the plugin
+            const result = await (0, loader_1.loadPlugin)(pluginPath);
+            if (!result.success || !result.plugin) {
+                console.error(`Failed to load plugin ${pluginName}:`, result.error);
+                return;
+            }
+            const loadedPlugin = result.plugin;
+            this.plugins.set(pluginName, loadedPlugin);
+            // Load configuration
+            const config = this.loadPluginConfig(pluginName);
+            this.configs.set(pluginName, config);
+            // Create plugin API
+            const api = this.createPluginAPI(pluginName, loadedPlugin);
+            // Register the plugin
+            await loadedPlugin.instance.register(api);
+            loadedPlugin.state = 'registered';
+            this.emitPluginEvent('plugin:registered', pluginName);
+            console.log(`Plugin ${pluginName} registered successfully`);
+        }
+        catch (error) {
+            console.error(`Error registering plugin ${pluginName}:`, error);
+            const loadedPlugin = this.plugins.get(pluginName);
+            if (loadedPlugin) {
+                loadedPlugin.state = 'error';
+                loadedPlugin.error = error instanceof Error ? error : new Error(String(error));
+            }
+            this.emitPluginEvent('plugin:error', pluginName, { error });
+        }
+    }
+    /**
+     * Create the Plugin API for a specific plugin
+     */
+    createPluginAPI(pluginName, loadedPlugin) {
+        const runtime = {
+            version: COWORK_VERSION,
+            platform: process.platform,
+            appDataPath: electron_1.app?.getPath?.('userData') || path.join(process.env.HOME || '', '.cowork'),
+            pluginDataPath: (0, loader_1.getPluginDataPath)(pluginName),
+            isDev: process.env.NODE_ENV === 'development',
+        };
+        return {
+            runtime,
+            registerChannel: (options) => {
+                this.channelAdapters.set(pluginName, options);
+                console.log(`Channel adapter registered by plugin: ${pluginName}`);
+            },
+            registerTool: (options) => {
+                const toolKey = `${pluginName}:${options.name}`;
+                this.tools.set(toolKey, options);
+                console.log(`Tool registered: ${toolKey}`);
+            },
+            getConfig: () => {
+                return (this.configs.get(pluginName) || {});
+            },
+            setConfig: async (config) => {
+                this.configs.set(pluginName, config);
+                await this.savePluginConfig(pluginName, config);
+                this.emitPluginEvent('plugin:config-changed', pluginName, { config });
+            },
+            getSecureStorage: () => {
+                return this.createSecureStorage(pluginName);
+            },
+            log: (level, message, ...args) => {
+                const prefix = `[${pluginName}]`;
+                switch (level) {
+                    case 'debug':
+                        console.debug(prefix, message, ...args);
+                        break;
+                    case 'info':
+                        console.log(prefix, message, ...args);
+                        break;
+                    case 'warn':
+                        console.warn(prefix, message, ...args);
+                        break;
+                    case 'error':
+                        console.error(prefix, message, ...args);
+                        break;
+                }
+            },
+            emit: (event, data) => {
+                const handlers = this.pluginEventHandlers.get(pluginName)?.get(event);
+                if (handlers) {
+                    for (const handler of handlers) {
+                        try {
+                            handler(data);
+                        }
+                        catch (e) {
+                            console.error(`Error in plugin event handler:`, e);
+                        }
+                    }
+                }
+            },
+            on: (event, handler) => {
+                if (!this.pluginEventHandlers.has(pluginName)) {
+                    this.pluginEventHandlers.set(pluginName, new Map());
+                }
+                const pluginHandlers = this.pluginEventHandlers.get(pluginName);
+                if (!pluginHandlers.has(event)) {
+                    pluginHandlers.set(event, new Set());
+                }
+                pluginHandlers.get(event).add(handler);
+            },
+            off: (event, handler) => {
+                this.pluginEventHandlers.get(pluginName)?.get(event)?.delete(handler);
+            },
+        };
+    }
+    /**
+     * Create secure storage for a plugin
+     */
+    createSecureStorage(pluginName) {
+        // Use a simple file-based storage for now
+        // In production, this should use the OS keychain
+        const storagePath = path.join((0, loader_1.getPluginDataPath)(pluginName), '.secrets');
+        const readSecrets = () => {
+            if (!fs.existsSync(storagePath)) {
+                return {};
+            }
+            try {
+                return JSON.parse(fs.readFileSync(storagePath, 'utf-8'));
+            }
+            catch {
+                return {};
+            }
+        };
+        const writeSecrets = (secrets) => {
+            fs.writeFileSync(storagePath, JSON.stringify(secrets), { mode: 0o600 });
+        };
+        return {
+            get: async (key) => {
+                const secrets = readSecrets();
+                return secrets[key] || null;
+            },
+            set: async (key, value) => {
+                const secrets = readSecrets();
+                secrets[key] = value;
+                writeSecrets(secrets);
+            },
+            delete: async (key) => {
+                const secrets = readSecrets();
+                delete secrets[key];
+                writeSecrets(secrets);
+            },
+            has: async (key) => {
+                const secrets = readSecrets();
+                return key in secrets;
+            },
+        };
+    }
+    /**
+     * Load plugin configuration from disk
+     */
+    loadPluginConfig(pluginName) {
+        const configPath = path.join((0, loader_1.getPluginDataPath)(pluginName), 'config.json');
+        if (!fs.existsSync(configPath)) {
+            // Return default config from manifest
+            const plugin = this.plugins.get(pluginName);
+            if (plugin?.manifest.configSchema?.properties) {
+                const defaults = {};
+                for (const [key, prop] of Object.entries(plugin.manifest.configSchema.properties)) {
+                    if (prop.default !== undefined) {
+                        defaults[key] = prop.default;
+                    }
+                }
+                return defaults;
+            }
+            return {};
+        }
+        try {
+            return JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * Save plugin configuration to disk
+     */
+    async savePluginConfig(pluginName, config) {
+        const configPath = path.join((0, loader_1.getPluginDataPath)(pluginName), 'config.json');
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    /**
+     * Emit a plugin event
+     */
+    emitPluginEvent(type, pluginName, data) {
+        const event = {
+            type,
+            pluginName,
+            timestamp: new Date(),
+            data,
+        };
+        this.emit(type, event);
+    }
+    // ============================================================================
+    // Public API
+    // ============================================================================
+    /**
+     * Get all loaded plugins
+     */
+    getPlugins() {
+        return Array.from(this.plugins.values());
+    }
+    /**
+     * Get a plugin by name
+     */
+    getPlugin(name) {
+        return this.plugins.get(name);
+    }
+    /**
+     * Get plugins by type
+     */
+    getPluginsByType(type) {
+        return Array.from(this.plugins.values())
+            .filter(p => p.manifest.type === type);
+    }
+    /**
+     * Check if a plugin is loaded
+     */
+    hasPlugin(name) {
+        return this.plugins.has(name);
+    }
+    /**
+     * Get channel adapter factory for a plugin
+     */
+    getChannelAdapter(pluginName) {
+        return this.channelAdapters.get(pluginName);
+    }
+    /**
+     * Get all registered channel adapters
+     */
+    getChannelAdapters() {
+        return new Map(this.channelAdapters);
+    }
+    /**
+     * Create a channel adapter instance from a plugin
+     */
+    createChannelAdapterFromPlugin(pluginName, config) {
+        const adapterFactory = this.channelAdapters.get(pluginName);
+        if (!adapterFactory) {
+            return null;
+        }
+        return adapterFactory.createAdapter(config);
+    }
+    /**
+     * Get all registered tools
+     */
+    getTools() {
+        return new Map(this.tools);
+    }
+    /**
+     * Get a specific tool
+     */
+    getTool(pluginName, toolName) {
+        return this.tools.get(`${pluginName}:${toolName}`);
+    }
+    /**
+     * Enable a plugin
+     */
+    async enablePlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`Plugin not found: ${name}`);
+        }
+        if (plugin.state === 'active') {
+            return;
+        }
+        plugin.state = 'active';
+        this.emitPluginEvent('plugin:loaded', name);
+    }
+    /**
+     * Disable a plugin
+     */
+    async disablePlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`Plugin not found: ${name}`);
+        }
+        if (plugin.state === 'disabled') {
+            return;
+        }
+        // Call unregister if available
+        if (plugin.instance.unregister) {
+            try {
+                await plugin.instance.unregister();
+            }
+            catch (error) {
+                console.error(`Error unregistering plugin ${name}:`, error);
+            }
+        }
+        plugin.state = 'disabled';
+        this.emitPluginEvent('plugin:unregistered', name);
+    }
+    /**
+     * Unload a plugin completely
+     */
+    async unloadPlugin(name) {
+        await this.disablePlugin(name);
+        // Remove from all registries
+        this.plugins.delete(name);
+        this.channelAdapters.delete(name);
+        this.configs.delete(name);
+        this.pluginEventHandlers.delete(name);
+        // Remove tools for this plugin
+        for (const key of this.tools.keys()) {
+            if (key.startsWith(`${name}:`)) {
+                this.tools.delete(key);
+            }
+        }
+    }
+    /**
+     * Reload a plugin
+     */
+    async reloadPlugin(name) {
+        const plugin = this.plugins.get(name);
+        if (!plugin) {
+            throw new Error(`Plugin not found: ${name}`);
+        }
+        const pluginPath = plugin.path;
+        await this.unloadPlugin(name);
+        // Clear require cache
+        const entryPoint = path.join(pluginPath, plugin.manifest.main);
+        delete require.cache[require.resolve(entryPoint)];
+        // Reload
+        const result = await (0, loader_1.loadPlugin)(pluginPath);
+        if (result.success && result.plugin) {
+            await this.loadAndRegister(pluginPath, result.plugin.manifest);
+        }
+    }
+    /**
+     * Get plugin configuration
+     */
+    getPluginConfig(name) {
+        return this.configs.get(name);
+    }
+    /**
+     * Set plugin configuration
+     */
+    async setPluginConfig(name, config) {
+        if (!this.plugins.has(name)) {
+            throw new Error(`Plugin not found: ${name}`);
+        }
+        this.configs.set(name, config);
+        await this.savePluginConfig(name, config);
+        this.emitPluginEvent('plugin:config-changed', name, { config });
+    }
+    /**
+     * Shutdown the registry
+     */
+    async shutdown() {
+        console.log('Shutting down plugin registry...');
+        for (const [name, plugin] of this.plugins) {
+            try {
+                if (plugin.instance.unregister) {
+                    await plugin.instance.unregister();
+                }
+            }
+            catch (error) {
+                console.error(`Error unregistering plugin ${name}:`, error);
+            }
+        }
+        this.plugins.clear();
+        this.channelAdapters.clear();
+        this.tools.clear();
+        this.configs.clear();
+        this.pluginEventHandlers.clear();
+        this.initialized = false;
+        console.log('Plugin registry shutdown complete');
+    }
+}
+exports.PluginRegistry = PluginRegistry;
+// Export singleton getter
+const getPluginRegistry = () => PluginRegistry.getInstance();
+exports.getPluginRegistry = getPluginRegistry;

package/dist/electron/electron/extensions/types.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Extension System Types
+ *
+ * Defines the plugin manifest schema and interfaces for the CoWork extension system.
+ * Extensions are loaded from cowork.plugin.json files and can provide:
+ * - Channel adapters (messaging platforms)
+ * - Tools (agent capabilities)
+ * - Providers (LLM, search, etc.)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });