@adversity/coding-tool-x 2.6.1 → 3.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adversity/coding-tool-x",
-  "version": "2.6.1",
+  "version": "3.0.0",
   "description": "Vibe Coding 增强工作助手 - 智能会话管理、动态渠道切换、全局搜索、实时监控",
   "main": "src/index.js",
   "bin": {
@@ -33,6 +33,7 @@
     "bin/",
     "src/commands/",
     "src/config/",
+    "src/plugins/",
     "src/server/",
     "src/ui/",
     "src/utils/",

package/src/plugins/constants.js

@@ -0,0 +1,14 @@
+const path = require('path');
+const os = require('os');
+
+const PLUGINS_DIR = path.join(os.homedir(), '.claude', 'cc-tool', 'plugins');
+const REGISTRY_FILE = path.join(PLUGINS_DIR, 'registry.json');
+const CONFIG_DIR = path.join(PLUGINS_DIR, 'config');
+const INSTALLED_DIR = path.join(PLUGINS_DIR, 'installed');
+
+module.exports = {
+  PLUGINS_DIR,
+  REGISTRY_FILE,
+  CONFIG_DIR,
+  INSTALLED_DIR,
+};

package/src/plugins/event-bus.js

@@ -0,0 +1,54 @@
+const { EventEmitter } = require('events');
+
+class PluginEventBus extends EventEmitter {
+  constructor() {
+    super();
+    this.setMaxListeners(50);
+  }
+
+  /**
+   * Emit event synchronously with error isolation
+   * All listener errors are caught and logged, not propagated
+   * @param {string} event - Event name
+   * @param {*} payload - Event payload
+   */
+  emitSync(event, payload) {
+    const listeners = this.listeners(event);
+    
+    listeners.forEach((listener) => {
+      try {
+        listener(payload);
+      } catch (error) {
+        console.error(
+          `[PluginEventBus] Error in listener for event "${event}":`,
+          error.message
+        );
+      }
+    });
+  }
+
+  /**
+   * Emit event asynchronously with error isolation
+   * Listeners are awaited sequentially; errors are caught and logged
+   * @param {string} event - Event name
+   * @param {*} payload - Event payload
+   * @returns {Promise<void>}
+   */
+  async emitAsync(event, payload) {
+    const listeners = this.listeners(event);
+    
+    for (const listener of listeners) {
+      try {
+        await listener(payload);
+      } catch (error) {
+        console.error(
+          `[PluginEventBus] Error in async listener for event "${event}":`,
+          error.message
+        );
+      }
+    }
+  }
+}
+
+// Export singleton instance
+module.exports = new PluginEventBus();

package/src/plugins/manifest-validator.js

@@ -0,0 +1,129 @@
+const Ajv = require('ajv');
+const semver = require('semver');
+const path = require('path');
+const fs = require('fs');
+
+/**
+ * Validate a plugin manifest against the JSON schema
+ * @param {Object} manifest - The manifest object to validate
+ * @returns {{ valid: boolean, errors: Array<{field: string, message: string}> }}
+ */
+function validateManifest(manifest) {
+  try {
+    // Load the schema
+    const schemaPath = path.join(__dirname, 'schema', 'plugin-manifest.json');
+
+    if (!fs.existsSync(schemaPath)) {
+      return {
+        valid: false,
+        errors: [{
+          field: 'schema',
+          message: `Schema file not found at ${schemaPath}`
+        }]
+      };
+    }
+
+    const schema = JSON.parse(fs.readFileSync(schemaPath, 'utf8'));
+
+    // Initialize AJV with strict mode and formats
+    const ajv = new Ajv({
+      allErrors: true,
+      strict: true,
+      validateFormats: false // Disable format validation to avoid unknown format errors
+    });
+
+    const validate = ajv.compile(schema);
+    const valid = validate(manifest);
+
+    if (!valid) {
+      // Transform AJV errors into a more user-friendly format
+      const errors = validate.errors.map(err => ({
+        field: err.instancePath || err.params?.missingProperty || 'root',
+        message: err.message || 'Validation failed',
+        details: err
+      }));
+
+      return {
+        valid: false,
+        errors
+      };
+    }
+
+    return {
+      valid: true,
+      errors: []
+    };
+
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [{
+        field: 'validator',
+        message: `Validation error: ${error.message}`
+      }]
+    };
+  }
+}
+
+/**
+ * Check if the plugin's minimum version requirement is compatible with current CTX version
+ * @param {string} minVersion - Minimum version required by plugin (e.g., "2.5.0")
+ * @returns {{ compatible: boolean, reason: string }}
+ */
+function checkVersionCompatibility(minVersion) {
+  try {
+    // Load CTX version from package.json
+    const packagePath = path.join(__dirname, '..', '..', 'package.json');
+
+    if (!fs.existsSync(packagePath)) {
+      return {
+        compatible: false,
+        reason: 'Could not find CTX package.json to determine version'
+      };
+    }
+
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+    const currentVersion = packageJson.version;
+
+    // Validate versions are valid semver
+    if (!semver.valid(minVersion)) {
+      return {
+        compatible: false,
+        reason: `Invalid minVersion format: "${minVersion}". Must be a valid semantic version (e.g., "2.5.0")`
+      };
+    }
+
+    if (!semver.valid(currentVersion)) {
+      return {
+        compatible: false,
+        reason: `Invalid CTX version format: "${currentVersion}"`
+      };
+    }
+
+    // Check if current version satisfies minimum requirement
+    const compatible = semver.gte(currentVersion, minVersion);
+
+    if (!compatible) {
+      return {
+        compatible: false,
+        reason: `Plugin requires CTX >= ${minVersion}, but current version is ${currentVersion}`
+      };
+    }
+
+    return {
+      compatible: true,
+      reason: `CTX version ${currentVersion} meets minimum requirement ${minVersion}`
+    };
+
+  } catch (error) {
+    return {
+      compatible: false,
+      reason: `Version compatibility check failed: ${error.message}`
+    };
+  }
+}
+
+module.exports = {
+  validateManifest,
+  checkVersionCompatibility
+};

package/src/plugins/plugin-api.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+const { CONFIG_DIR } = require('./constants');
+const eventBus = require('./event-bus');
+const { loadConfig } = require('../config/loader');
+const packageJson = require('../../package.json');
+
+/**
+ * Create sandboxed plugin context with isolated API surface
+ * @param {string} pluginName - Name of the plugin
+ * @param {Object} pluginConfig - Plugin-specific configuration
+ * @param {string} pluginDir - Plugin installation directory
+ * @returns {Object} Plugin context object
+ */
+function createPluginContext(pluginName, pluginConfig, pluginDir) {
+  const commandRegistry = new Map();
+
+  // Storage API - persists plugin data to ~/.claude/cc-tool/plugins/config/<plugin-name>.json
+  const storage = createStorageAPI(pluginName);
+
+  // Logger API - prefixed logging
+  const logger = {
+    info: (msg) => console.log(`[${pluginName}] ${msg}`),
+    warn: (msg) => console.warn(`[${pluginName}] ${msg}`),
+    error: (msg) => console.error(`[${pluginName}] ${msg}`),
+  };
+
+  // Plugin context object
+  const ctx = {
+    // Event bus for cross-plugin communication
+    events: eventBus,
+
+    // Frozen plugin configuration
+    config: Object.freeze({ ...pluginConfig }),
+
+    // Prefixed logger
+    logger,
+
+    // Command registration (collected by plugin-manager)
+    registerCommand: (name, handler) => {
+      if (!name || typeof name !== 'string') {
+        throw new Error('Command name must be a non-empty string');
+      }
+      if (typeof handler !== 'function') {
+        throw new Error('Command handler must be a function');
+      }
+      commandRegistry.set(name, handler);
+      logger.info(`Registered command: ${name}`);
+    },
+
+    // Get frozen copy of app configuration
+    getAppConfig: () => {
+      const config = loadConfig();
+      return Object.freeze({ ...config });
+    },
+
+    // Get CTX version
+    getVersion: () => packageJson.version,
+
+    // Persistent key-value storage
+    storage,
+
+    // Internal: expose command registry for plugin-manager
+    _getCommands: () => commandRegistry,
+  };
+
+  return ctx;
+}
+
+/**
+ * Create storage API for plugin data persistence
+ * @param {string} pluginName - Plugin name
+ * @returns {Object} Storage API
+ */
+function createStorageAPI(pluginName) {
+  const storageFile = path.join(CONFIG_DIR, `${pluginName}.json`);
+
+  // Ensure config directory exists
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+
+  // Load storage data
+  function loadData() {
+    try {
+      if (fs.existsSync(storageFile)) {
+        const content = fs.readFileSync(storageFile, 'utf8');
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      console.error(`[${pluginName}] Failed to load storage:`, error.message);
+    }
+    return {};
+  }
+
+  // Save storage data
+  function saveData(data) {
+    try {
+      fs.writeFileSync(storageFile, JSON.stringify(data, null, 2));
+    } catch (error) {
+      console.error(`[${pluginName}] Failed to save storage:`, error.message);
+      throw error;
+    }
+  }
+
+  return {
+    get: (key) => {
+      const data = loadData();
+      return data[key];
+    },
+
+    set: (key, value) => {
+      const data = loadData();
+      data[key] = value;
+      saveData(data);
+    },
+
+    delete: (key) => {
+      const data = loadData();
+      delete data[key];
+      saveData(data);
+    },
+  };
+}
+
+module.exports = {
+  createPluginContext,
+};