@adversity/coding-tool-x 2.6.0 → 3.0.0

package/src/plugins/plugin-loader.js

@@ -0,0 +1,229 @@
+const fs = require('fs');
+const path = require('path');
+const { getPlugin } = require('./registry');
+const { INSTALLED_DIR, CONFIG_DIR } = require('./constants');
+const { createPluginContext } = require('./plugin-api');
+
+// Track loaded plugins
+const loadedPlugins = new Map();
+
+/**
+ * Load and activate a plugin
+ * @param {string} name - Plugin name
+ * @returns {Object} Result object with success status and optional error
+ */
+function loadPlugin(name) {
+  // ERROR ISOLATION: Wrap entire function to prevent CTX crash
+  try {
+    // Check if already loaded
+    if (loadedPlugins.has(name)) {
+      return {
+        success: true,
+        message: `Plugin '${name}' already loaded`,
+      };
+    }
+
+    // Get plugin info from registry
+    const pluginInfo = getPlugin(name);
+    if (!pluginInfo) {
+      return {
+        success: false,
+        error: `Plugin '${name}' not found in registry`,
+      };
+    }
+
+    // Check if enabled
+    if (!pluginInfo.enabled) {
+      return {
+        success: false,
+        error: `Plugin '${name}' is disabled`,
+      };
+    }
+
+    // Construct path to installed plugin
+    const pluginDir = path.join(INSTALLED_DIR, name);
+    if (!fs.existsSync(pluginDir)) {
+      return {
+        success: false,
+        error: `Plugin directory not found: ${pluginDir}`,
+      };
+    }
+
+    // Read and validate plugin.json
+    const pluginJsonPath = path.join(pluginDir, 'plugin.json');
+    if (!fs.existsSync(pluginJsonPath)) {
+      return {
+        success: false,
+        error: `plugin.json not found in ${pluginDir}`,
+      };
+    }
+
+    let pluginJson;
+    try {
+      const content = fs.readFileSync(pluginJsonPath, 'utf8');
+      pluginJson = JSON.parse(content);
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to parse plugin.json: ${error.message}`,
+      };
+    }
+
+    // Validate plugin.json structure
+    if (!pluginJson.name || !pluginJson.version || !pluginJson.main) {
+      return {
+        success: false,
+        error: 'Invalid plugin.json: missing name, version, or main',
+      };
+    }
+
+    // Require plugin's main file
+    const mainPath = path.join(pluginDir, pluginJson.main);
+
+    // SECURITY: Verify resolved path is within pluginDir (prevent path traversal)
+    const resolvedMainPath = path.resolve(mainPath);
+    const resolvedPluginDir = path.resolve(pluginDir);
+    if (!resolvedMainPath.startsWith(resolvedPluginDir + path.sep)) {
+      return {
+        success: false,
+        error: `Security violation: Main file path traversal detected: ${pluginJson.main}`,
+      };
+    }
+
+    if (!fs.existsSync(mainPath)) {
+      return {
+        success: false,
+        error: `Main file not found: ${mainPath}`,
+      };
+    }
+
+    let pluginModule;
+    try {
+      pluginModule = require(mainPath);
+    } catch (error) {
+      return {
+        success: false,
+        error: `Failed to require plugin: ${error.message}`,
+      };
+    }
+
+    // Verify exports: { activate, deactivate }
+    if (typeof pluginModule.activate !== 'function') {
+      return {
+        success: false,
+        error: 'Plugin must export an activate() function',
+      };
+    }
+
+    // Load plugin-specific configuration
+    const pluginConfigPath = path.join(CONFIG_DIR, `${name}.json`);
+    let pluginConfig = {};
+    if (fs.existsSync(pluginConfigPath)) {
+      try {
+        const configContent = fs.readFileSync(pluginConfigPath, 'utf8');
+        pluginConfig = JSON.parse(configContent);
+      } catch (error) {
+        // Non-fatal: log but continue with empty config
+        console.warn(`[plugin-loader] Failed to load config for ${name}:`, error.message);
+      }
+    }
+
+    // Create plugin context
+    const ctx = createPluginContext(name, pluginConfig, pluginDir);
+
+    // Call activate() wrapped in try/catch
+    try {
+      pluginModule.activate(ctx);
+    } catch (error) {
+      return {
+        success: false,
+        error: `Plugin activation failed: ${error.message}`,
+      };
+    }
+
+    // Track loaded plugin
+    loadedPlugins.set(name, {
+      module: pluginModule,
+      context: ctx,
+      info: pluginJson,
+      loadedAt: new Date().toISOString(),
+    });
+
+    return {
+      success: true,
+      message: `Plugin '${name}' loaded successfully`,
+    };
+  } catch (error) {
+    // ERROR ISOLATION: Catch any unexpected errors
+    return {
+      success: false,
+      error: `Unexpected error loading plugin '${name}': ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Unload and deactivate a plugin
+ * @param {string} name - Plugin name
+ * @returns {Object} Result object with success status
+ */
+function unloadPlugin(name) {
+  try {
+    // Check if loaded
+    if (!loadedPlugins.has(name)) {
+      return {
+        success: false,
+        error: `Plugin '${name}' is not loaded`,
+      };
+    }
+
+    const plugin = loadedPlugins.get(name);
+
+    // Call deactivate() if exists
+    if (typeof plugin.module.deactivate === 'function') {
+      try {
+        plugin.module.deactivate();
+      } catch (error) {
+        // Log but don't fail unload
+        console.error(`[plugin-loader] Error during deactivation of '${name}':`, error.message);
+      }
+    }
+
+    // Remove from tracking
+    loadedPlugins.delete(name);
+
+    return {
+      success: true,
+      message: `Plugin '${name}' unloaded successfully`,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Unexpected error unloading plugin '${name}': ${error.message}`,
+    };
+  }
+}
+
+/**
+ * Get list of currently loaded plugin names
+ * @returns {Array<string>} Array of loaded plugin names
+ */
+function getLoadedPlugins() {
+  return Array.from(loadedPlugins.keys());
+}
+
+/**
+ * Get loaded plugin details (internal use)
+ * @param {string} name - Plugin name
+ * @returns {Object|undefined} Plugin details or undefined
+ */
+function getLoadedPluginDetails(name) {
+  return loadedPlugins.get(name);
+}
+
+module.exports = {
+  loadPlugin,
+  unloadPlugin,
+  getLoadedPlugins,
+  getLoadedPluginDetails,
+};

package/src/plugins/plugin-manager.js

@@ -0,0 +1,170 @@
+const { loadRegistry, listPlugins } = require('./registry');
+const { loadPlugin, unloadPlugin, getLoadedPlugins, getLoadedPluginDetails } = require('./plugin-loader');
+const eventBus = require('./event-bus');
+
+// Module state
+let initialized = false;
+const registeredCommands = new Map(); // { commandName: { pluginName, handler } }
+
+/**
+ * Initialize all enabled plugins
+ * @param {Object} [options] - Initialization options
+ * @param {Object} [options.config] - Application configuration
+ * @param {Array} [options.args] - CLI arguments
+ * @returns {Object} Result with loaded count and failed plugins
+ */
+function initializePlugins(options = {}) {
+  if (initialized) {
+    return {
+      loaded: getLoadedPlugins().length,
+      failed: [],
+      message: 'Plugins already initialized',
+    };
+  }
+
+  const { config = {}, args = [] } = options;
+  const failed = [];
+  let loadedCount = 0;
+
+  // Load registry
+  const registry = loadRegistry();
+  const plugins = Object.entries(registry.plugins || {});
+
+  // Sort plugins by loadOrder (lower = earlier)
+  const sortedPlugins = plugins
+    .filter(([, info]) => info.enabled)
+    .sort((a, b) => (a[1].loadOrder || 10) - (b[1].loadOrder || 10));
+
+  // Load each enabled plugin
+  for (const [name] of sortedPlugins) {
+    const result = loadPlugin(name);
+
+    if (result.success) {
+      loadedCount++;
+
+      // Collect registered commands from this plugin
+      const pluginDetails = getLoadedPluginDetails(name);
+      if (pluginDetails && pluginDetails.context) {
+        const commands = pluginDetails.context._getCommands();
+        commands.forEach((handler, cmdName) => {
+          registeredCommands.set(cmdName, { pluginName: name, handler });
+        });
+      }
+    } else {
+      failed.push({ name, error: result.error });
+    }
+  }
+
+  // Emit cli:init event
+  eventBus.emitSync('cli:init', { config, args });
+
+  initialized = true;
+
+  return {
+    loaded: loadedCount,
+    failed,
+  };
+}
+
+/**
+ * Shutdown all loaded plugins
+ * @returns {Object} Confirmation of shutdown
+ */
+function shutdownPlugins() {
+  if (!initialized) {
+    return {
+      success: true,
+      message: 'Plugins not initialized, nothing to shutdown',
+    };
+  }
+
+  // Emit cli:shutdown event
+  eventBus.emitSync('cli:shutdown', {});
+
+  // Unload each loaded plugin in reverse order
+  const loadedNames = getLoadedPlugins();
+  const errors = [];
+
+  for (const name of loadedNames.reverse()) {
+    const result = unloadPlugin(name);
+    if (!result.success) {
+      errors.push({ name, error: result.error });
+    }
+  }
+
+  // Clear command registry
+  registeredCommands.clear();
+  initialized = false;
+
+  return {
+    success: errors.length === 0,
+    unloaded: loadedNames.length - errors.length,
+    errors,
+  };
+}
+
+/**
+ * Get all registered commands from plugins
+ * @returns {Map} Map of { commandName: { pluginName, handler } }
+ */
+function getRegisteredCommands() {
+  return new Map(registeredCommands);
+}
+
+/**
+ * Check if a command is registered by a plugin
+ * @param {string} name - Command name
+ * @returns {boolean} True if command exists
+ */
+function isPluginCommand(name) {
+  return registeredCommands.has(name);
+}
+
+/**
+ * Execute a plugin-registered command
+ * @param {string} name - Command name
+ * @param {Array} args - Command arguments
+ * @returns {Object} Result with success status and result/error
+ */
+async function executePluginCommand(name, args = []) {
+  if (!registeredCommands.has(name)) {
+    return {
+      success: false,
+      error: `Command '${name}' not found`,
+    };
+  }
+
+  const { pluginName, handler } = registeredCommands.get(name);
+
+  try {
+    const result = await handler(args);
+    return {
+      success: true,
+      result,
+      pluginName,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: `Error executing command '${name}' from plugin '${pluginName}': ${error.message}`,
+      pluginName,
+    };
+  }
+}
+
+/**
+ * Check if plugins are initialized
+ * @returns {boolean} Initialization status
+ */
+function isInitialized() {
+  return initialized;
+}
+
+module.exports = {
+  initializePlugins,
+  shutdownPlugins,
+  getRegisteredCommands,
+  isPluginCommand,
+  executePluginCommand,
+  isInitialized,
+};

package/src/plugins/registry.js

@@ -0,0 +1,152 @@
+const fs = require('fs');
+const path = require('path');
+const { PLUGINS_DIR, REGISTRY_FILE } = require('./constants');
+
+/**
+ * Ensure plugins directory exists
+ */
+function ensurePluginsDir() {
+  if (!fs.existsSync(PLUGINS_DIR)) {
+    fs.mkdirSync(PLUGINS_DIR, { recursive: true });
+  }
+}
+
+/**
+ * Load registry.json, create with empty structure if missing
+ * @returns {Object} Registry data
+ */
+function loadRegistry() {
+  ensurePluginsDir();
+
+  if (!fs.existsSync(REGISTRY_FILE)) {
+    const emptyRegistry = { plugins: {} };
+    fs.writeFileSync(REGISTRY_FILE, JSON.stringify(emptyRegistry, null, 2), 'utf8');
+    return emptyRegistry;
+  }
+
+  try {
+    const content = fs.readFileSync(REGISTRY_FILE, 'utf8');
+    const data = JSON.parse(content);
+
+    // Ensure plugins key exists
+    if (!data.plugins) {
+      data.plugins = {};
+    }
+
+    return data;
+  } catch (error) {
+    console.error('Failed to load registry:', error.message);
+    return { plugins: {} };
+  }
+}
+
+/**
+ * Save registry data to registry.json
+ * @param {Object} data - Registry data
+ */
+function saveRegistry(data) {
+  ensurePluginsDir();
+
+  try {
+    fs.writeFileSync(REGISTRY_FILE, JSON.stringify(data, null, 2), 'utf8');
+  } catch (error) {
+    throw new Error(`Failed to save registry: ${error.message}`);
+  }
+}
+
+/**
+ * Add plugin to registry
+ * @param {string} name - Plugin name
+ * @param {Object} info - Plugin information
+ * @param {string} info.version - Plugin version
+ * @param {boolean} [info.enabled=true] - Whether plugin is enabled
+ * @param {string} [info.installedAt] - Installation timestamp
+ * @param {string} [info.source] - Git URL or source
+ * @param {number} [info.loadOrder=10] - Load order priority
+ * @returns {Object} Updated registry
+ */
+function addPlugin(name, info) {
+  const registry = loadRegistry();
+
+  registry.plugins[name] = {
+    version: info.version,
+    enabled: info.enabled !== undefined ? info.enabled : true,
+    installedAt: info.installedAt || new Date().toISOString(),
+    source: info.source || '',
+    loadOrder: info.loadOrder !== undefined ? info.loadOrder : 10,
+  };
+
+  saveRegistry(registry);
+  return registry;
+}
+
+/**
+ * Remove plugin from registry
+ * @param {string} name - Plugin name
+ * @returns {Object} Updated registry
+ */
+function removePlugin(name) {
+  const registry = loadRegistry();
+
+  if (registry.plugins[name]) {
+    delete registry.plugins[name];
+    saveRegistry(registry);
+  }
+
+  return registry;
+}
+
+/**
+ * Get plugin info
+ * @param {string} name - Plugin name
+ * @returns {Object|null} Plugin info or null if not found
+ */
+function getPlugin(name) {
+  const registry = loadRegistry();
+  return registry.plugins[name] || null;
+}
+
+/**
+ * List all plugins
+ * @returns {Array} Array of plugin objects with name included
+ */
+function listPlugins() {
+  const registry = loadRegistry();
+
+  return Object.entries(registry.plugins).map(([name, info]) => ({
+    name,
+    ...info,
+  }));
+}
+
+/**
+ * Update plugin info (partial update)
+ * @param {string} name - Plugin name
+ * @param {Object} updates - Partial updates to apply
+ * @returns {Object} Updated plugin info
+ */
+function updatePlugin(name, updates) {
+  const registry = loadRegistry();
+
+  if (!registry.plugins[name]) {
+    throw new Error(`Plugin '${name}' not found in registry`);
+  }
+
+  registry.plugins[name] = {
+    ...registry.plugins[name],
+    ...updates,
+  };
+
+  saveRegistry(registry);
+  return registry.plugins[name];
+}
+
+module.exports = {
+  loadRegistry,
+  saveRegistry,
+  addPlugin,
+  removePlugin,
+  getPlugin,
+  listPlugins,
+  updatePlugin,
+};

package/src/plugins/schema/plugin-manifest.json

@@ -0,0 +1,115 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/zhangzeao/coding-tool/blob/main/src/plugins/schema/plugin-manifest.json",
+  "title": "CTX Plugin Manifest",
+  "description": "Schema for Coding-Tool-X (ctx) plugin manifest file",
+  "type": "object",
+  "required": ["name", "version", "description", "main", "ctx"],
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "Plugin name in kebab-case, must start with 'ctx-plugin-'",
+      "pattern": "^ctx-plugin-[a-z0-9-]+$"
+    },
+    "version": {
+      "type": "string",
+      "description": "Semantic version string",
+      "pattern": "^\\d+\\.\\d+\\.\\d+(-[a-zA-Z0-9.-]+)?(\\+[a-zA-Z0-9.-]+)?$"
+    },
+    "description": {
+      "type": "string",
+      "description": "Brief description of what the plugin does",
+      "minLength": 1,
+      "maxLength": 200
+    },
+    "main": {
+      "type": "string",
+      "description": "Entry point JavaScript file (relative to plugin root)",
+      "pattern": "^(?!.*\\.\\.)(?!.*\\.\\/)[a-zA-Z0-9_-]+(?:\\/[a-zA-Z0-9_-]+)*\\.js$"
+    },
+    "ctx": {
+      "type": "object",
+      "description": "CTX-specific metadata",
+      "required": ["minVersion", "hooks"],
+      "properties": {
+        "minVersion": {
+          "type": "string",
+          "description": "Minimum CTX version required",
+          "pattern": "^\\d+\\.\\d+\\.\\d+$"
+        },
+        "hooks": {
+          "type": "array",
+          "description": "Lifecycle hooks this plugin subscribes to",
+          "items": {
+            "type": "string",
+            "enum": [
+              "cli:init",
+              "cli:shutdown",
+              "cli:command:before",
+              "cli:command:after",
+              "config:loaded",
+              "config:saved",
+              "proxy:start",
+              "proxy:stop"
+            ]
+          },
+          "uniqueItems": true,
+          "minItems": 1
+        }
+      },
+      "additionalProperties": false
+    },
+    "author": {
+      "type": "string",
+      "description": "Author name and optional email"
+    },
+    "license": {
+      "type": "string",
+      "description": "SPDX license identifier"
+    },
+    "repository": {
+      "type": "string",
+      "description": "Git repository URL",
+      "format": "uri"
+    },
+    "dependencies": {
+      "type": "object",
+      "description": "npm dependencies (will be installed automatically)",
+      "patternProperties": {
+        "^[a-z0-9-_@/]+$": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "config": {
+      "type": "object",
+      "description": "Default configuration values for this plugin"
+    },
+    "commands": {
+      "type": "array",
+      "description": "CLI commands registered by this plugin",
+      "items": {
+        "type": "object",
+        "required": ["name", "description"],
+        "properties": {
+          "name": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$",
+            "description": "Command name (kebab-case)"
+          },
+          "description": {
+            "type": "string",
+            "description": "Command description shown in help"
+          },
+          "usage": {
+            "type": "string",
+            "description": "Usage example"
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/src/server/api/mcp.js

@@ -341,7 +341,7 @@ router.get('/servers/:id/tools', async (req, res) => {
   try {
     const { id } = req.params;
     const result = await mcpService.getServerTools(id);
-    res.json(result);
+    res.json({ success: true, ...result });
   } catch (err) {
     res.status(404).json({ success: false, error: err.message });
   }