coding-tool-x 3.8.4 → 3.8.6

package/src/platforms/runtime.js

@@ -0,0 +1,259 @@
+'use strict';
+
+const path = require('path');
+const { createPlatformRegistry } = require('./registry');
+const { resolveTemplate } = require('./path-resolver');
+const { createPlatformPathContext } = require('./platform-path-context');
+
+const PATH_CONTEXT_ENV_KEYS = [
+  'HOME',
+  'USERPROFILE',
+  'APPDATA',
+  'CLAUDE_CONFIG_DIR',
+  'CODEX_HOME',
+  'XDG_CONFIG_HOME',
+  'XDG_DATA_HOME',
+  'XDG_STATE_HOME',
+  'PATH',
+  'OMP_COMMAND',
+  'OMP_CONFIG_DIR',
+  'OMP_PROFILE',
+  'PI_CODING_AGENT_DIR',
+  'OMP_CODING_AGENT_DIR'
+];
+
+let platformRegistry;
+let platformRuntime;
+let defaultDependencies = Object.freeze({});
+
+function getDefaultDriverRegistry() {
+  try {
+    const { getDriverRegistry } = require('./driver-registry');
+    return getDriverRegistry();
+  } catch (error) {
+    if (error.code !== 'MODULE_NOT_FOUND' || !error.message.includes("'./driver-registry'")) throw error;
+    throw new Error('Platform driver registry is not available; create(id, context) cannot be resolved');
+  }
+}
+
+function isUrl(value) {
+  return /^[a-z][a-z0-9+.-]*:\/\//i.test(String(value));
+}
+
+function isExplicitFilesystemRoot(value) {
+  return path.isAbsolute(String(value));
+}
+
+function expandTilde(value, homeDir) {
+  if (value === '~') return homeDir;
+  if (value.startsWith('~/') || value.startsWith('~\\')) return path.join(homeDir, value.slice(2));
+  return value;
+}
+
+function assertInsideHome(home, candidate, manifestKey, mappingName) {
+  const relative = path.relative(home, candidate);
+  if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+    throw new Error(`Manifest ${manifestKey || 'platform'} resource mapping ${mappingName} escapes home`);
+  }
+}
+
+function hasDeclaredHome(manifest) {
+  return Boolean(manifest && manifest.paths && Object.prototype.hasOwnProperty.call(manifest.paths, 'home'));
+}
+
+function resolveResourceMappings(manifest, resolvedPaths = {}, pathOptions = {}, strictHome = false) {
+  const resourceMappings = manifest.resourceMappings || {};
+  const home = resolvedPaths.home || process.cwd();
+  const homeDir = pathOptions.homeDir || require('os').homedir();
+  const declaredHome = hasDeclaredHome(manifest);
+  const resolved = { env: { ...process.env, ...(pathOptions.env || {}) }, home };
+  return Object.fromEntries(Object.entries(resourceMappings).map(([type, value]) => {
+    if (typeof value === 'string' && !value.trim()) return [type, value];
+    const raw = expandTilde(resolveTemplate(value, resolved), homeDir);
+    const target = isUrl(raw) || path.isAbsolute(raw) ? raw : path.join(home, raw);
+    const requiresContainment = !isExplicitFilesystemRoot(value) || (strictHome && declaredHome);
+    if (!isUrl(target) && requiresContainment) assertInsideHome(home, path.normalize(target), manifest.key, type);
+    return [type, isUrl(target) ? target : path.normalize(target)];
+  }));
+}
+
+function resolvePromptFile(manifest, resolvedPaths = {}, pathOptions = {}, strictHome = false) {
+  if (manifest.promptFile === null || manifest.promptFile === undefined) return manifest.promptFile;
+  if (typeof manifest.promptFile === 'string' && !manifest.promptFile.trim()) return manifest.promptFile;
+  const home = resolvedPaths.home || process.cwd();
+  const homeDir = pathOptions.homeDir || require('os').homedir();
+  const raw = expandTilde(resolveTemplate(manifest.promptFile, { env: { ...process.env, ...(pathOptions.env || {}) }, home }), homeDir);
+  if (isUrl(raw)) throw new Error(`Manifest ${manifest.key || 'platform'} promptFile must be a filesystem path`);
+  const target = path.isAbsolute(raw) ? path.normalize(raw) : path.normalize(path.join(home, raw));
+  const requiresContainment = !isExplicitFilesystemRoot(manifest.promptFile) || (strictHome && hasDeclaredHome(manifest));
+  if (requiresContainment) assertInsideHome(home, target, manifest.key, 'promptFile');
+  return target;
+}
+
+function buildResolvedManifest(rawManifest, resolvedPaths, pathOptions = {}, driverId) {
+  if (!rawManifest) return null;
+  const paths = resolvedPaths || rawManifest.paths;
+  const strictHome = driverId === 'generic-mcp' || driverId === 'generic-prompt';
+  const resourceMappings = rawManifest.resourceMappings
+    ? resolveResourceMappings(rawManifest, paths || {}, pathOptions, strictHome)
+    : rawManifest.resourceMappings;
+  const promptFile = resolvePromptFile(rawManifest, paths || {}, pathOptions, strictHome);
+  const selectedMapping = driverId === 'generic-mcp'
+    ? rawManifest.resourceMappings && rawManifest.resourceMappings.mcp
+    : driverId === 'generic-prompt'
+      ? (rawManifest.resourceMappings && typeof rawManifest.resourceMappings.prompts === 'string' && rawManifest.resourceMappings.prompts.trim()
+        ? rawManifest.resourceMappings.prompts
+        : rawManifest.promptFile)
+      : null;
+  if (strictHome && !hasDeclaredHome(rawManifest) && isExplicitFilesystemRoot(selectedMapping) && paths && Object.prototype.hasOwnProperty.call(paths, 'home')) {
+    const driverPaths = { ...paths };
+    delete driverPaths.home;
+    return { ...rawManifest, paths: driverPaths, resourceMappings, promptFile };
+  }
+  return { ...rawManifest, paths, resourceMappings, promptFile };
+}
+
+function isLegacyDriverId(driverId) {
+  return typeof driverId === 'string' && driverId.startsWith('legacy:');
+}
+
+function getDefaultDependencies() {
+  return { ...defaultDependencies };
+}
+
+function canReuseDefaultPathContext(pathOptions = {}) {
+  return !pathOptions || (
+    typeof pathOptions === 'object'
+    && !Array.isArray(pathOptions)
+    && Object.keys(pathOptions).length === 0
+  );
+}
+
+function getDefaultPathContextFingerprint(platform, manifest) {
+  try {
+    const pathConfig = require('../config/paths');
+    const nativeKey = manifest?.pathResolverId || platform;
+    const native = pathConfig.NATIVE_PATHS?.[nativeKey] || null;
+    const state = typeof pathConfig.getPlatformStatePaths === 'function'
+      ? pathConfig.getPlatformStatePaths(platform)
+      : null;
+    let homeDir = pathConfig.HOME_DIR || '';
+    if (!homeDir) {
+      const { resolvePreferredHomeDir } = require('../utils/home-dir');
+      homeDir = typeof resolvePreferredHomeDir === 'function'
+        ? resolvePreferredHomeDir(process.platform, process.env, require('os').homedir())
+        : '';
+    }
+    return JSON.stringify({
+      homeDir,
+      native,
+      state,
+      env: Object.fromEntries(PATH_CONTEXT_ENV_KEYS.map(key => [key, process.env[key] || '']))
+    });
+  } catch {
+    return '';
+  }
+}
+
+function configureDefaultDependencies(dependencies = {}) {
+  if (!dependencies || typeof dependencies !== 'object' || Array.isArray(dependencies)) {
+    throw new TypeError('Platform default dependencies must be an object');
+  }
+  defaultDependencies = Object.freeze({ ...dependencies });
+  return getDefaultDependencies();
+}
+
+function createPlatformRuntime({ registry, driverRegistry, dependencies = {} } = {}) {
+  const resolvedDependencies = { ...dependencies };
+  const resolvedRegistry = registry || createPlatformRegistry();
+  const defaultPathContextCache = new Map();
+  const runtime = {
+    getDriver(platform, capability, context = {}) {
+      const driverId = resolvedRegistry.getCapability(platform, capability);
+      if (!driverId) return null;
+      if (!driverRegistry || typeof driverRegistry.create !== 'function') return null;
+      const rawManifest = typeof resolvedRegistry.resolve === 'function' ? resolvedRegistry.resolve(platform) : null;
+      const pathOptions = context.pathResolver || context.pathResolverOptions || resolvedDependencies.pathResolver || resolvedDependencies.pathResolverOptions || {};
+      let pathContext = null;
+      let resolvedPaths = null;
+      if (rawManifest) {
+        const cacheKey = String(platform || '').trim().toLowerCase();
+        const useCache = canReuseDefaultPathContext(pathOptions);
+        const cached = useCache ? defaultPathContextCache.get(cacheKey) : null;
+        const pathContextFingerprint = useCache
+          ? getDefaultPathContextFingerprint(cacheKey, rawManifest)
+          : '';
+        if (cached && cached.fingerprint === pathContextFingerprint) {
+          ({ pathContext, resolvedPaths } = cached);
+        } else {
+          if (typeof resolvedRegistry.resolvePathContext === 'function') {
+            pathContext = resolvedRegistry.resolvePathContext(platform, pathOptions);
+            resolvedPaths = pathContext && pathContext.paths;
+          } else if (typeof resolvedRegistry.resolvePaths === 'function') {
+            resolvedPaths = resolvedRegistry.resolvePaths(platform, pathOptions);
+            pathContext = createPlatformPathContext({
+              key: platform,
+              manifest: rawManifest,
+              resolvedPaths,
+              pathOptions
+            });
+          }
+          if (useCache && (pathContext || resolvedPaths)) {
+            defaultPathContextCache.set(cacheKey, {
+              pathContext,
+              resolvedPaths,
+              fingerprint: pathContextFingerprint
+            });
+          }
+        }
+      }
+      const manifest = isLegacyDriverId(driverId)
+        ? rawManifest
+        : buildResolvedManifest(rawManifest, resolvedPaths, pathOptions, driverId);
+      const driverContext = {
+        ...resolvedDependencies,
+        platform,
+        capability,
+        manifest,
+        pathContext,
+        paths: pathContext ? pathContext.native : resolvedPaths,
+        context,
+        dependencies: resolvedDependencies
+      };
+      Object.defineProperty(driverContext, 'runtime', { value: runtime });
+      return driverRegistry.create(driverId, driverContext);
+    },
+    invoke(platform, capability, operation, args = []) {
+      const driver = runtime.getDriver(platform, capability);
+      if (!driver || typeof driver[operation] !== 'function') {
+        throw new Error(`Unsupported platform capability operation: ${platform}.${capability}.${operation}`);
+      }
+      return driver[operation](...args);
+    }
+  };
+  return runtime;
+}
+
+function getPlatformRegistry() {
+  if (!platformRegistry) platformRegistry = createPlatformRegistry();
+  return platformRegistry;
+}
+
+function getPlatformRuntime() {
+  if (!platformRuntime) {
+    platformRuntime = createPlatformRuntime({
+      registry: getPlatformRegistry(),
+      driverRegistry: getDefaultDriverRegistry(),
+      dependencies: getDefaultDependencies()
+    });
+  }
+  return platformRuntime;
+}
+
+module.exports = {
+  configureDefaultDependencies,
+  createPlatformRuntime,
+  getPlatformRegistry,
+  getPlatformRuntime,
+  getDefaultDependencies
+};

package/src/{server/services/session-history-adapters/index.js → platforms/session-history-adapters.js}

@@ -1,8 +1,15 @@
 'use strict';
 
+const ADAPTER_PATHS = Object.freeze({
+  claude: './drivers/claude/session-history-adapter',
+  codex: './drivers/codex/session-history-adapter',
+  gemini: './drivers/gemini/session-history-adapter',
+  omp: './drivers/omp/session-history-adapter'
+});
+
 function optionalAdapter(name) {
   try {
-    return require(`./${name}`);
+    return require(ADAPTER_PATHS[name]);
   } catch (_) {
     return {
       inventory: async () => [],

package/src/plugins/plugin-loader.js

@@ -12,7 +12,7 @@ const loadedPlugins = new Map();
  * @param {string} name - Plugin name
  * @returns {Object} Result object with success status and optional error
  */
-function loadPlugin(name) {
+function loadPlugin(name, options = {}) {
   // ERROR ISOLATION: Wrap entire function to prevent CTX crash
   try {
     // Check if already loaded
@@ -24,7 +24,7 @@ function loadPlugin(name) {
     }
 
     // Get plugin info from registry
-    const pluginInfo = getPlugin(name);
+    const pluginInfo = options.pluginInfo || getPlugin(name);
     if (!pluginInfo) {
       return {
         success: false,

package/src/plugins/plugin-manager.js

@@ -36,8 +36,8 @@ function initializePlugins(options = {}) {
     .sort((a, b) => (a[1].loadOrder || 10) - (b[1].loadOrder || 10));
 
   // Load each enabled plugin
-  for (const [name] of sortedPlugins) {
-    const result = loadPlugin(name);
+  for (const [name, pluginInfo] of sortedPlugins) {
+    const result = loadPlugin(name, { pluginInfo });
 
     if (result.success) {
       loadedCount++;

package/src/plugins/registry.js

@@ -2,6 +2,20 @@ const fs = require('fs');
 const path = require('path');
 const { PLUGINS_DIR, REGISTRY_FILE } = require('./constants');
 
+let registryCache = null;
+
+function getRegistryMtime() {
+  try {
+    return fs.statSync(REGISTRY_FILE).mtimeMs;
+  } catch {
+    return null;
+  }
+}
+function cacheRegistry(data) {
+  registryCache = { data, mtimeMs: getRegistryMtime() };
+  return data;
+}
+
 /**
  * Ensure plugins directory exists
  */
@@ -19,24 +33,26 @@ function loadRegistry() {
   ensurePluginsDir();
 
   if (!fs.existsSync(REGISTRY_FILE)) {
-    const emptyRegistry = { plugins: {} };
-    fs.writeFileSync(REGISTRY_FILE, JSON.stringify(emptyRegistry, null, 2), 'utf8');
-    return emptyRegistry;
+    const data = { plugins: {} };
+    saveRegistry(data);
+    return data;
+  }
+
+  const mtimeMs = getRegistryMtime();
+  if (registryCache && registryCache.mtimeMs === mtimeMs) {
+    return registryCache.data;
   }
 
   try {
     const content = fs.readFileSync(REGISTRY_FILE, 'utf8');
     const data = JSON.parse(content);
-
-    // Ensure plugins key exists
-    if (!data.plugins) {
-      data.plugins = {};
-    }
-
+    if (!data.plugins) data.plugins = {};
+    registryCache = { data, mtimeMs };
     return data;
   } catch (error) {
     console.error('Failed to load registry:', error.message);
-    return { plugins: {} };
+    registryCache = { data: { plugins: {} }, mtimeMs };
+    return registryCache.data;
   }
 }
 
@@ -49,6 +65,7 @@ function saveRegistry(data) {
 
   try {
     fs.writeFileSync(REGISTRY_FILE, JSON.stringify(data, null, 2), 'utf8');
+    cacheRegistry(data);
   } catch (error) {
     throw new Error(`Failed to save registry: ${error.message}`);
   }

package/src/reset-config.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const { PATHS, NATIVE_PATHS, ensureStorageDirMigrated } = require('./config/paths');
 const { isWindowsLikePlatform } = require('./utils/home-dir');
+const { getPlatformContext } = require('./server/platform-context');
 
 function buildEchoCommand(value) {
   if (isWindowsLikePlatform(process.platform, process.env)) {
@@ -14,10 +15,25 @@ async function resetConfig() {
   console.log('\n开始恢复默认配置...\n');
   ensureStorageDirMigrated();
 
+  let claudeNativePaths = NATIVE_PATHS.claude;
+  let claudeStatePaths = {
+    activeChannel: PATHS.activeChannel.claude,
+    channels: PATHS.channels.claude
+  };
+  try {
+    const pathContext = getPlatformContext().registry.resolvePathContext('claude');
+    if (pathContext?.customized) {
+      claudeNativePaths = { ...claudeNativePaths, ...(pathContext.native || {}) };
+      claudeStatePaths = { ...claudeStatePaths, ...(pathContext.state || {}) };
+    }
+  } catch (_) {
+    // Keep legacy defaults when reset is invoked without a usable registry.
+  }
+
   try {
     // 1. 尝试停止代理服务器（如果正在运行）
     try {
-      const { stopProxyServer, getProxyStatus } = require('./server/proxy-server');
+      const { stopProxyServer, getProxyStatus } = require('./platforms/drivers/claude/proxy-implementation');
       const status = getProxyStatus();
 
       if (status.running) {
@@ -31,8 +47,8 @@ async function resetConfig() {
     }
 
     // 2. 检查并恢复 settings.json
-    const settingsPath = NATIVE_PATHS.claude.settings;
-    const backupPath = NATIVE_PATHS.claude.settingsBackup;
+    const settingsPath = claudeNativePaths.settings;
+    const backupPath = claudeNativePaths.settingsBackup;
 
     if (fs.existsSync(backupPath)) {
       console.log('发现备份文件，正在恢复...');
@@ -50,10 +66,10 @@ async function resetConfig() {
         console.log('检测到代理配置，尝试恢复到正常渠道...');
 
         // 读取激活的渠道
-        const activeChannelPath = PATHS.activeChannel.claude;
+        const activeChannelPath = claudeStatePaths.activeChannel;
         if (fs.existsSync(activeChannelPath)) {
           const activeChannelData = JSON.parse(fs.readFileSync(activeChannelPath, 'utf8'));
-          const channelsPath = PATHS.channels.claude;
+          const channelsPath = claudeStatePaths.channels;
 
           if (fs.existsSync(channelsPath)) {
             const channelsData = JSON.parse(fs.readFileSync(channelsPath, 'utf8'));