coding-tool-x 3.3.8 → 3.4.0

package/src/server/services/codex-env-manager.js

@@ -0,0 +1,426 @@
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { PATHS, HOME_DIR } = require('../../config/paths');
+
+const PROFILE_MARKER_START = '# >>> coding-tool codex env >>>';
+const PROFILE_MARKER_END = '# <<< coding-tool codex env <<<';
+
+function defaultEnvFilePath(configDir) {
+  return path.join(configDir, 'codex-env.sh');
+}
+
+function defaultStateFilePath(configDir) {
+  return path.join(configDir, 'codex-env-state.json');
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function hasValue(value) {
+  return String(value || '').trim() !== '';
+}
+
+function shellQuote(value) {
+  return `'${String(value).replace(/'/g, `'\"'\"'`)}'`;
+}
+
+function powershellQuote(value) {
+  return `'${String(value).replace(/'/g, "''")}'`;
+}
+
+function buildHomeRelativeShellPath(filePath, homeDir) {
+  const normalizedHome = path.resolve(homeDir);
+  const normalizedFilePath = path.resolve(filePath);
+  if (normalizedFilePath === normalizedHome) {
+    return '$HOME';
+  }
+  if (normalizedFilePath.startsWith(`${normalizedHome}${path.sep}`)) {
+    const relativePath = normalizedFilePath.slice(normalizedHome.length).replace(/\\/g, '/');
+    return `$HOME${relativePath}`;
+  }
+  return normalizedFilePath.replace(/\\/g, '/');
+}
+
+function buildSourceSnippet(envFilePath, homeDir) {
+  const shellPath = buildHomeRelativeShellPath(envFilePath, homeDir);
+  return [
+    PROFILE_MARKER_START,
+    `[ -f "${shellPath}" ] && . "${shellPath}"`,
+    PROFILE_MARKER_END
+  ].join('\n');
+}
+
+function stripManagedBlock(content = '') {
+  if (!content.includes(PROFILE_MARKER_START)) {
+    return content;
+  }
+  const pattern = new RegExp(
+    `\\n?${escapeRegex(PROFILE_MARKER_START)}[\\s\\S]*?${escapeRegex(PROFILE_MARKER_END)}\\n?`,
+    'g'
+  );
+  return content.replace(pattern, '\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function escapeRegex(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function upsertManagedBlock(content, snippet) {
+  const stripped = stripManagedBlock(content);
+  if (!stripped.trim()) {
+    return `${snippet}\n`;
+  }
+  return `${stripped.trimEnd()}\n\n${snippet}\n`;
+}
+
+function readJsonFile(filePath, fallbackValue) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return fallbackValue;
+    }
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallbackValue;
+  }
+}
+
+function writeJsonFile(filePath, payload) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8');
+}
+
+function readState(stateFilePath) {
+  const state = readJsonFile(stateFilePath, {
+    version: 1,
+    values: {},
+    profiles: []
+  });
+  return {
+    version: 1,
+    values: state && typeof state.values === 'object' ? state.values : {},
+    profiles: Array.isArray(state?.profiles) ? state.profiles : []
+  };
+}
+
+function normalizeEnvMap(envMap = {}) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(envMap || {})) {
+    if (!key || !hasValue(value)) continue;
+    normalized[String(key).trim()] = String(value);
+  }
+  return normalized;
+}
+
+function buildNextEnvValues(previousValues, envMap, { replace = true, removeKeys = [] } = {}) {
+  const nextValues = replace
+    ? {}
+    : { ...previousValues };
+
+  if (replace) {
+    Object.assign(nextValues, normalizeEnvMap(envMap));
+  } else {
+    const normalizedIncoming = normalizeEnvMap(envMap);
+    for (const [key, value] of Object.entries(normalizedIncoming)) {
+      nextValues[key] = value;
+    }
+  }
+
+  for (const key of removeKeys || []) {
+    delete nextValues[key];
+  }
+
+  for (const [key, value] of Object.entries(nextValues)) {
+    if (!hasValue(value)) {
+      delete nextValues[key];
+    }
+  }
+
+  return nextValues;
+}
+
+function getPosixProfileCandidates(homeDir, shellEnv = process.env) {
+  const candidates = [
+    '.bashrc',
+    '.bash_profile',
+    '.bash_login',
+    '.zshrc',
+    '.zshenv',
+    '.zprofile',
+    '.zlogin',
+    '.profile'
+  ].map(fileName => path.join(homeDir, fileName));
+
+  const shell = String(shellEnv.SHELL || '').toLowerCase();
+  const preferred = shell.includes('zsh')
+    ? path.join(homeDir, '.zshrc')
+    : shell.includes('bash')
+      ? path.join(homeDir, '.bashrc')
+      : path.join(homeDir, '.profile');
+
+  return {
+    preferred,
+    candidates
+  };
+}
+
+function writeTextFileIfChanged(filePath, content) {
+  const previous = fs.existsSync(filePath) ? fs.readFileSync(filePath, 'utf8') : null;
+  if (previous === content) {
+    return false;
+  }
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, content, 'utf8');
+  return true;
+}
+
+function syncPosixEnvironment(nextValues, previousState, options) {
+  const {
+    runtime,
+    homeDir,
+    stateFilePath,
+    shellEnv,
+    execSync
+  } = options;
+  const nextKeys = Object.keys(nextValues).sort();
+  let changed = false;
+
+  // 清理旧版本遗留的 shell profile 注入（迁移兼容）
+  const previousProfiles = Array.isArray(previousState.profiles) ? previousState.profiles : [];
+  if (previousProfiles.length > 0) {
+    const { candidates } = getPosixProfileCandidates(homeDir, shellEnv);
+    const cleanupTargets = new Set([
+      ...previousProfiles,
+      ...candidates.filter(filePath => fs.existsSync(filePath))
+    ]);
+    for (const profilePath of cleanupTargets) {
+      if (!fs.existsSync(profilePath)) continue;
+      const currentContent = fs.readFileSync(profilePath, 'utf8');
+      if (!currentContent.includes(PROFILE_MARKER_START)) continue;
+      const nextContent = stripManagedBlock(currentContent);
+      const finalContent = nextContent ? `${nextContent}\n` : '';
+      changed = writeTextFileIfChanged(profilePath, finalContent) || changed;
+    }
+  }
+
+  // macOS：用 launchctl 写入全局环境变量，新开终端/进程即生效
+  if (runtime === 'darwin') {
+    applyLaunchctlEnvironment(previousState.values || {}, nextValues, execSync);
+    const prevValues = previousState.values || {};
+    const keysChanged =
+      Object.keys(nextValues).length !== Object.keys(prevValues).length ||
+      Object.entries(nextValues).some(([k, v]) => prevValues[k] !== v);
+    changed = changed || keysChanged;
+  }
+
+  // Linux：写 ~/.config/environment.d/（桌面/systemd）+ ~/.profile（SSH/登录shell）
+  if (runtime === 'linux') {
+    changed = applyLinuxEnvironment(nextValues, homeDir) || changed;
+  }
+
+  if (nextKeys.length > 0) {
+    writeJsonFile(stateFilePath, {
+      version: 1,
+      values: nextValues,
+      profiles: []
+    });
+  } else if (fs.existsSync(stateFilePath)) {
+    fs.unlinkSync(stateFilePath);
+  }
+
+  return {
+    changed,
+    reloadRequired: changed,
+    isFirstTime: Object.keys(previousState.values || {}).length === 0 && nextKeys.length > 0,
+    sourceCommand: null,
+    shellConfigPath: null,
+    shellConfigPaths: [],
+    envFilePath: null,
+    managedKeys: nextKeys
+  };
+}
+
+function applyLinuxEnvironment(nextValues, homeDir) {
+  let changed = false;
+
+  // 1. ~/.config/environment.d/codex-env.conf（systemd 用户环境，桌面终端生效）
+  const envdDir = path.join(homeDir, '.config', 'environment.d');
+  const envdFile = path.join(envdDir, 'codex-env.conf');
+  const nextKeys = Object.keys(nextValues).sort();
+
+  if (nextKeys.length > 0) {
+    const envdContent = [
+      '# Managed by Coding-Tool',
+      ...nextKeys.map(key => `${key}=${nextValues[key]}`),
+      ''
+    ].join('\n');
+    changed = writeTextFileIfChanged(envdFile, envdContent) || changed;
+  } else if (fs.existsSync(envdFile)) {
+    fs.unlinkSync(envdFile);
+    changed = true;
+  }
+
+  // 2. ~/.profile（登录 shell，SSH 和新终端均生效）
+  const profilePath = path.join(homeDir, '.profile');
+  if (nextKeys.length > 0) {
+    const exportLines = nextKeys.map(key => `export ${key}=${shellQuote(nextValues[key])}`).join('\n');
+    const snippet = [PROFILE_MARKER_START, exportLines, PROFILE_MARKER_END].join('\n');
+    const currentContent = fs.existsSync(profilePath) ? fs.readFileSync(profilePath, 'utf8') : '';
+    const nextContent = upsertManagedBlock(currentContent, snippet);
+    changed = writeTextFileIfChanged(profilePath, nextContent) || changed;
+  } else if (fs.existsSync(profilePath)) {
+    const currentContent = fs.readFileSync(profilePath, 'utf8');
+    if (currentContent.includes(PROFILE_MARKER_START)) {
+      const nextContent = stripManagedBlock(currentContent);
+      const finalContent = nextContent ? `${nextContent}\n` : '';
+      changed = writeTextFileIfChanged(profilePath, finalContent) || changed;
+    }
+  }
+
+  return changed;
+}
+
+function applyLaunchctlEnvironment(previousValues, nextValues, execSync) {
+  const previousKeys = new Set(Object.keys(previousValues || {}));
+  for (const [key, value] of Object.entries(nextValues || {})) {
+    if (previousValues[key] === value) {
+      previousKeys.delete(key);
+      continue;
+    }
+    runLaunchctlCommand(['setenv', key, value], execSync);
+    previousKeys.delete(key);
+  }
+  for (const key of previousKeys) {
+    runLaunchctlCommand(['unsetenv', key], execSync);
+  }
+}
+
+function runLaunchctlCommand(args, execSync) {
+  try {
+    execSync('launchctl', args, {
+      stdio: ['ignore', 'ignore', 'ignore'],
+      timeout: 3000
+    });
+  } catch {
+    // ignore launchctl failures; shell profile remains the durable source
+  }
+}
+
+function syncWindowsEnvironment(nextValues, previousState, options) {
+  const { stateFilePath, execSync } = options;
+  const nextKeys = Object.keys(nextValues).sort();
+  const previousValues = previousState.values || {};
+  let changed = false;
+
+  for (const [key, value] of Object.entries(nextValues)) {
+    if (previousValues[key] === value) continue;
+    setWindowsUserEnv(key, value, execSync);
+    changed = true;
+  }
+
+  for (const key of Object.keys(previousValues)) {
+    if (Object.prototype.hasOwnProperty.call(nextValues, key)) continue;
+    removeWindowsUserEnv(key, execSync);
+    changed = true;
+  }
+
+  if (nextKeys.length > 0) {
+    writeJsonFile(stateFilePath, {
+      version: 1,
+      values: nextValues,
+      profiles: []
+    });
+  } else if (fs.existsSync(stateFilePath)) {
+    fs.unlinkSync(stateFilePath);
+  }
+
+  return {
+    changed,
+    reloadRequired: changed,
+    isFirstTime: Object.keys(previousValues).length === 0 && nextKeys.length > 0,
+    sourceCommand: null,
+    shellConfigPath: null,
+    shellConfigPaths: [],
+    envFilePath: null,
+    managedKeys: nextKeys
+  };
+}
+
+function runWindowsEnvCommand(script, execSync) {
+  const candidates = ['powershell', 'pwsh'];
+  let lastError = null;
+  for (const command of candidates) {
+    try {
+      execSync(command, ['-NoProfile', '-NonInteractive', '-Command', script], {
+        stdio: ['ignore', 'ignore', 'ignore'],
+        timeout: 5000
+      });
+      return;
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw lastError || new Error('No PowerShell executable available');
+}
+
+function setWindowsUserEnv(key, value, execSync) {
+  runWindowsEnvCommand(
+    `[Environment]::SetEnvironmentVariable(${powershellQuote(key)}, ${powershellQuote(value)}, 'User')`,
+    execSync
+  );
+}
+
+function removeWindowsUserEnv(key, execSync) {
+  runWindowsEnvCommand(
+    `[Environment]::SetEnvironmentVariable(${powershellQuote(key)}, $null, 'User')`,
+    execSync
+  );
+}
+
+function syncCodexUserEnvironment(envMap = {}, options = {}) {
+  const configDir = options.configDir || PATHS.config;
+  const homeDir = options.homeDir || HOME_DIR;
+  const envFilePath = options.envFilePath || defaultEnvFilePath(configDir);
+  const stateFilePath = options.stateFilePath || defaultStateFilePath(configDir);
+  const runtime = options.runtime || process.platform;
+  const shellEnv = options.shellEnv || process.env;
+  const execSync = options.execFileSync || execFileSync;
+  const previousState = readState(stateFilePath);
+  const nextValues = buildNextEnvValues(previousState.values, envMap, {
+    replace: options.replace !== false,
+    removeKeys: options.removeKeys || []
+  });
+
+  const syncOptions = {
+    runtime,
+    homeDir,
+    envFilePath,
+    stateFilePath,
+    shellEnv,
+    execSync
+  };
+
+  if (runtime === 'win32') {
+    return syncWindowsEnvironment(nextValues, previousState, syncOptions);
+  }
+
+  return syncPosixEnvironment(nextValues, previousState, syncOptions);
+}
+
+module.exports = {
+  syncCodexUserEnvironment,
+  _test: {
+    buildHomeRelativeShellPath,
+    buildNextEnvValues,
+    buildSourceSnippet,
+    getPosixProfileCandidates,
+    readState,
+    shellQuote,
+    stripManagedBlock,
+    syncCodexUserEnvironment,
+    upsertManagedBlock
+  }
+};

package/src/server/services/codex-settings-manager.js

@@ -1,12 +1,9 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
 const toml = require('toml');
 const tomlStringify = require('@iarna/toml').stringify;
-const { resolvePreferredHomeDir } = require('../../utils/home-dir');
 const { NATIVE_PATHS } = require('../../config/paths');
-
-const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
+const { syncCodexUserEnvironment } = require('./codex-env-manager');
 
 // Codex 配置文件路径
 function getConfigPath() {
@@ -143,7 +140,7 @@ function backupSettings() {
     const configContent = fs.readFileSync(getConfigPath(), 'utf8');
     fs.writeFileSync(getConfigBackupPath(), configContent, 'utf8');
 
-    // 备份 auth.json (如果存在)
+    // 备份 auth.json (如果存在，主要用于 OAuth 状态回滚)
     if (authExists()) {
       const authContent = fs.readFileSync(getAuthPath(), 'utf8');
       fs.writeFileSync(getAuthBackupPath(), authContent, 'utf8');
@@ -194,8 +191,10 @@ function restoreSettings() {
       fs.unlinkSync(getAuthBackupPath());
     }
 
-    // auth.json 已恢复，同步删除当前进程的环境变量
-    delete process.env.CC_PROXY_KEY;
+    syncCodexUserEnvironment({}, {
+      replace: false,
+      removeKeys: ['CC_PROXY_KEY']
+    });
 
     console.log('Codex settings restored from backup');
     return { success: true };
@@ -232,20 +231,21 @@ function setProxyConfig(proxyPort) {
     // 写入配置
     writeConfig(config);
 
-    // 写入 auth.json
-    const auth = readAuth();
-    auth.CC_PROXY_KEY = 'PROXY_KEY';
-    writeAuth(auth);
+    const envResult = syncCodexUserEnvironment({
+      CC_PROXY_KEY: 'PROXY_KEY'
+    }, {
+      replace: false
+    });
 
-    // auth.json 已写入 CC_PROXY_KEY，Codex 优先读取 auth.json，无需注入 shell 配置文件
     console.log(`Codex settings updated to use proxy on port ${proxyPort}`);
     return {
       success: true,
       port: proxyPort,
       envInjected: true,
-      isFirstTime: false,
-      shellConfigPath: null,
-      sourceCommand: null
+      isFirstTime: envResult.isFirstTime,
+      shellConfigPath: envResult.shellConfigPath,
+      sourceCommand: envResult.sourceCommand,
+      reloadRequired: envResult.reloadRequired
     };
   } catch (err) {
     throw new Error('Failed to set proxy config: ' + err.message);

package/src/server/services/codex-statistics-service.js

@@ -4,36 +4,12 @@ const {
   getDailyStatistics: getSharedDailyStatistics,
   getTodayStatistics: getSharedTodayStatistics
 } = require('./statistics-service');
+const { normalizeUsageTokens, toNumber } = require('./proxy-log-helper');
 
 const TOOL_TYPE = 'codex';
 
-function toNumber(value) {
-  const num = Number(value);
-  return Number.isFinite(num) ? num : 0;
-}
-
-function normalizeToolTokens(tokens = {}) {
-  const input = toNumber(tokens.input);
-  const output = toNumber(tokens.output);
-  const reasoning = toNumber(tokens.reasoning);
-  const cached = toNumber(tokens.cached);
-  const cacheCreation = toNumber(tokens.cacheCreation);
-  const cacheRead = toNumber(tokens.cacheRead || cached);
-  const total = toNumber(tokens.total) || (input + output + reasoning);
-
-  return {
-    input,
-    output,
-    reasoning,
-    cached,
-    cacheCreation,
-    cacheRead,
-    total
-  };
-}
-
 function toLegacyEntryShape(entry = {}, includeName = false) {
-  const normalized = normalizeToolTokens(entry.tokens || {});
+  const normalized = normalizeUsageTokens(TOOL_TYPE, entry.tokens || {});
   const result = {
     requests: toNumber(entry.requests),
     tokens: {
@@ -126,7 +102,7 @@ function buildDailyStatistics(sharedDaily = {}, fallbackDate) {
 }
 
 function recordRequest(requestData = {}) {
-  const normalizedTokens = normalizeToolTokens(requestData.tokens || {});
+  const normalizedTokens = normalizeUsageTokens(TOOL_TYPE, requestData.tokens || {});
   return recordSharedRequest({
     ...requestData,
     toolType: TOOL_TYPE,

package/src/server/services/config-export-service.js

@@ -39,11 +39,11 @@ const PLUGIN_SENSITIVE_PATTERNS = [
   /\.p12$/i,
   /\.pfx$/i
 ];
-const CC_UI_CONFIG_PATH = path.join(CC_TOOL_DIR, 'ui-config.json');
-const CC_PROMPTS_PATH = path.join(CC_TOOL_DIR, 'prompts.json');
-const CC_SECURITY_PATH = path.join(CC_TOOL_DIR, 'security.json');
-const LEGACY_UI_CONFIG_PATH = path.join(LEGACY_CC_TOOL_DIR, 'ui-config.json');
-const LEGACY_NOTIFY_HOOK_PATH = path.join(LEGACY_CC_TOOL_DIR, 'notify-hook.js');
+const CC_UI_CONFIG_PATH = PATHS.uiConfig;
+const CC_PROMPTS_PATH = PATHS.prompts;
+const CC_SECURITY_PATH = PATHS.security;
+const LEGACY_UI_CONFIG_PATH = PATHS.uiConfig;
+const LEGACY_NOTIFY_HOOK_PATH = PATHS.notifyHook;
 const GEMINI_SETTINGS_PATH = path.join(path.dirname(NATIVE_PATHS.gemini.env), 'settings.json');
 const AGENT_PLATFORMS = ['claude', 'codex', 'opencode'];
 const COMMAND_PLATFORMS = ['claude', 'opencode'];
@@ -58,8 +58,18 @@ function getOpenCodeConfigPaths() {
   }
 }
 
+function getOpenCodeNotificationPluginPath() {
+  try {
+    const { getOpenCodeManagedPluginPath } = require('./notification-hooks');
+    return typeof getOpenCodeManagedPluginPath === 'function' ? getOpenCodeManagedPluginPath() : '';
+  } catch (err) {
+    return '';
+  }
+}
+
 function getNativeConfigSpecs() {
   const openCodeConfigPaths = getOpenCodeConfigPaths();
+  const openCodeNotificationPluginPath = getOpenCodeNotificationPluginPath();
   return {
     claude: {
       settings: { path: NATIVE_PATHS.claude.settings, format: 'json' }
@@ -75,7 +85,10 @@ function getNativeConfigSpecs() {
     opencode: {
       opencodeJsonc: { path: openCodeConfigPaths.opencodec, format: 'text' },
       opencodeJson: { path: openCodeConfigPaths.opencode, format: 'text' },
-      configJson: { path: openCodeConfigPaths.config, format: 'text' }
+      configJson: { path: openCodeConfigPaths.config, format: 'text' },
+      ...(openCodeNotificationPluginPath
+        ? { codingToolNotifyPlugin: { path: openCodeNotificationPluginPath, format: 'text' } }
+        : {})
     }
   };
 }
@@ -212,7 +225,7 @@ function buildExportReadme(exportData) {
 - Prompts 预设
 - 安全配置
 - 高级配置（端口、日志、性能等）
-- Claude Hooks 配置（如通知脚本）
+- 通知 Hook / 插件脚本（如 notify-hook.js）
 
 > 注意：配置包可能包含 API Key、Webhook 等敏感信息，请妥善保管。
 `;

package/src/server/services/config-registry-service.js

@@ -13,8 +13,8 @@ const { PATHS, NATIVE_PATHS } = require('../../config/paths');
 
 // Configuration paths
 const CC_TOOL_DIR = PATHS.base;
-const REGISTRY_FILE = path.join(CC_TOOL_DIR, 'config-registry.json');
-const CONFIGS_DIR = path.join(CC_TOOL_DIR, 'configs');
+const REGISTRY_FILE = PATHS.configRegistry;
+const CONFIGS_DIR = PATHS.configs;
 
 // Claude Code native directories
 const CLAUDE_HOME_DIR = path.dirname(NATIVE_PATHS.claude.settings);
@@ -113,6 +113,7 @@ class ConfigRegistryService {
    */
   _ensureDirs() {
     ensureDir(CC_TOOL_DIR);
+    ensureDir(path.dirname(this.registryPath));
     ensureDir(this.configsDir);
 
     for (const type of CONFIG_TYPES) {

package/src/server/services/config-sync-manager.js

@@ -24,7 +24,7 @@ const { PATHS, NATIVE_PATHS, HOME_DIR, ensureStorageDirMigrated } = require('../
 
 // Paths
 const HOME = HOME_DIR || os.homedir();
-const CC_TOOL_CONFIGS = path.join(PATHS.base, 'configs');
+const CC_TOOL_CONFIGS = PATHS.configs;
 const CLAUDE_CODE_DIR = path.join(HOME, '.claude');
 const CODEX_DIR = path.join(HOME, '.codex');
 const GEMINI_DIR = path.join(HOME, '.gemini');

package/src/server/services/favorites.js

@@ -1,7 +1,7 @@
 const fs = require('fs');
+const path = require('path');
 const { PATHS } = require('../../config/paths');
 
-const FAVORITES_DIR = PATHS.base;
 const FAVORITES_FILE = PATHS.favorites;
 
 // 内存缓存
@@ -17,8 +17,9 @@ const DEFAULT_FAVORITES = {
 
 // Ensure favorites directory exists
 function ensureFavoritesDir() {
-  if (!fs.existsSync(FAVORITES_DIR)) {
-    fs.mkdirSync(FAVORITES_DIR, { recursive: true });
+  const dir = path.dirname(FAVORITES_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }
 

package/src/server/services/gemini-channels.js

@@ -32,9 +32,9 @@ function getGeminiDir() {
 
 // 获取渠道存储文件路径
 function getChannelsFilePath() {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const channelsDir = path.dirname(PATHS.channels.gemini);
+  if (!fs.existsSync(channelsDir)) {
+    fs.mkdirSync(channelsDir, { recursive: true });
   }
   return PATHS.channels.gemini;
 }