coding-tool-x 3.3.8 → 3.4.0

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

@@ -43,17 +43,17 @@ function normalizeChannelName(value) {
 
 // 获取渠道存储文件路径
 function getChannelsFilePath() {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const channelsDir = path.dirname(PATHS.channels.opencode);
+  if (!fs.existsSync(channelsDir)) {
+    fs.mkdirSync(channelsDir, { recursive: true });
   }
   return PATHS.channels.opencode;
 }
 
 function getCodexChannelsFilePath() {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const channelsDir = path.dirname(PATHS.channels.codex);
+  if (!fs.existsSync(channelsDir)) {
+    fs.mkdirSync(channelsDir, { recursive: true });
   }
   return PATHS.channels.codex;
 }

package/src/server/services/opencode-sessions.js

@@ -9,8 +9,8 @@ const { NATIVE_PATHS, PATHS } = require('../../config/paths');
  * 读取 OpenCode SQLite 会话数据
  */
 
-const PROJECT_ORDER_FILE = path.join(PATHS.base, 'opencode-project-order.json');
-const SESSION_ORDER_FILE = path.join(PATHS.base, 'opencode-session-order.json');
+const PROJECT_ORDER_FILE = PATHS.opencodeProjectOrder;
+const SESSION_ORDER_FILE = PATHS.opencodeSessionOrder;
 const OPENCODE_DB_PATH = path.join(NATIVE_PATHS.opencode.data, 'opencode.db');
 const COUNTS_CACHE_TTL_MS = 30 * 1000;
 const EMPTY_COUNTS = Object.freeze({ projectCount: 0, sessionCount: 0 });

package/src/server/services/opencode-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 = 'opencode';
 
-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/plugins-service.js

@@ -10,7 +10,7 @@ const { listPlugins, getPlugin, updatePlugin: updatePluginRegistry } = require('
 const { installPlugin: installPluginCore, uninstallPlugin: uninstallPluginCore } = require('../../plugins/plugin-installer');
 const { initializePlugins, shutdownPlugins } = require('../../plugins/plugin-manager');
 const { INSTALLED_DIR, CONFIG_DIR } = require('../../plugins/constants');
-const { NATIVE_PATHS, HOME_DIR } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 
 const CLAUDE_PLUGINS_DIR = path.join(path.dirname(NATIVE_PATHS.claude.settings), 'plugins');
 const CLAUDE_INSTALLED_FILE = path.join(CLAUDE_PLUGINS_DIR, 'installed_plugins.json');
@@ -106,14 +106,79 @@ function stripJsonComments(input = '') {
 class PluginsService {
   constructor(platform = 'claude') {
     this.platform = ['claude', 'opencode'].includes(platform) ? platform : 'claude';
-    this.ccToolConfigDir = path.join(HOME_DIR, '.cc-tool');
+    this.ccToolConfigDir = path.dirname(PATHS.pluginRepos.claude);
     this.opencodePluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugins');
     this.opencodeLegacyPluginsDir = path.join(OPENCODE_CONFIG_DIR, 'plugin');
-    const prefix = this.platform === 'opencode' ? 'opencode-' : '';
-    this.marketCachePath = path.join(this.ccToolConfigDir, `${prefix}plugins-market-cache.json`);
+    this.marketCachePath = this.platform === 'opencode'
+      ? PATHS.pluginMarketCache.opencode
+      : PATHS.pluginMarketCache.claude;
     this._marketCache = null;
   }
 
+  clearMarketCache({ removeFile = true } = {}) {
+    this._marketCache = null;
+    if (removeFile) {
+      try {
+        if (fs.existsSync(this.marketCachePath)) {
+          fs.unlinkSync(this.marketCachePath);
+        }
+      } catch (err) {
+        // ignore cache deletion errors
+      }
+    }
+  }
+
+  loadMarketCacheFromFile() {
+    try {
+      if (fs.existsSync(this.marketCachePath)) {
+        const data = JSON.parse(fs.readFileSync(this.marketCachePath, 'utf-8'));
+        if (Array.isArray(data.plugins)) {
+          return data.plugins;
+        }
+      }
+    } catch (err) {
+      // ignore cache read errors
+    }
+    return null;
+  }
+
+  saveMarketCacheToFile(plugins) {
+    try {
+      this._ensureDir(path.dirname(this.marketCachePath));
+      fs.writeFileSync(this.marketCachePath, JSON.stringify({ plugins }), 'utf-8');
+    } catch (err) {
+      // ignore cache write errors
+    }
+  }
+
+  prepareMarketPlugins(plugins = []) {
+    const preparedPlugins = Array.isArray(plugins)
+      ? plugins.map(plugin => ({ ...plugin }))
+      : [];
+    const seen = new Set();
+    const installedPlugins = this.listPlugins().plugins;
+    const installedNames = new Set(installedPlugins.map(p => p.name));
+
+    const deduped = [];
+    for (const plugin of preparedPlugins) {
+      const key = [
+        plugin.name || '',
+        plugin.repoOwner || '',
+        plugin.repoName || '',
+        plugin.directory || plugin.installSource || ''
+      ].join('::');
+      if (seen.has(key)) continue;
+      seen.add(key);
+      deduped.push({
+        ...plugin,
+        isInstalled: installedNames.has(plugin.name)
+      });
+    }
+
+    deduped.sort((a, b) => (a.name || '').toLowerCase().localeCompare((b.name || '').toLowerCase()));
+    return deduped;
+  }
+
   _ensureDir(dirPath) {
     if (!fs.existsSync(dirPath)) {
       fs.mkdirSync(dirPath, { recursive: true });
@@ -780,11 +845,9 @@ class PluginsService {
    * @returns {string} Config file path
    */
   getReposConfigPath() {
-    this._ensureDir(this.ccToolConfigDir);
-    if (this._isOpenCode()) {
-      return path.join(this.ccToolConfigDir, 'opencode-plugin-repos.json');
-    }
-    return path.join(this.ccToolConfigDir, 'plugin-repos.json');
+    const filePath = this._isOpenCode() ? PATHS.pluginRepos.opencode : PATHS.pluginRepos.claude;
+    this._ensureDir(path.dirname(filePath));
+    return filePath;
   }
 
   _getDefaultRepos() {
@@ -936,6 +999,7 @@ class PluginsService {
 
     config.repos.push(newRepo);
     this.saveReposConfig(config);
+    this.clearMarketCache();
 
     return config.repos;
   }
@@ -950,6 +1014,7 @@ class PluginsService {
     const config = this.loadReposConfig();
     config.repos = config.repos.filter(r => !(r.owner === owner && r.name === name));
     this.saveReposConfig(config);
+    this.clearMarketCache();
     return config.repos;
   }
 
@@ -968,6 +1033,7 @@ class PluginsService {
     }
     repo.enabled = enabled;
     this.saveReposConfig(config);
+    this.clearMarketCache();
     return config.repos;
   }
 
@@ -1157,21 +1223,29 @@ class PluginsService {
    * @returns {Promise<Array>} List of available market plugins
    */
   async getMarketPlugins(forceRefresh = false) {
-    if (!forceRefresh) {
-      if (this._marketCache) return this._marketCache;
-      try {
-        if (fs.existsSync(this.marketCachePath)) {
-          const data = JSON.parse(fs.readFileSync(this.marketCachePath, 'utf-8'));
-          if (Array.isArray(data.plugins)) {
-            this._marketCache = data.plugins;
-            return this._marketCache;
-          }
-        }
-      } catch (err) { /* ignore */ }
+    if (forceRefresh) {
+      this.clearMarketCache({ removeFile: false });
+    }
+
+    const fileCache = this.loadMarketCacheFromFile();
+
+    if (!forceRefresh && Array.isArray(this._marketCache) && this._marketCache.length > 0) {
+      if (Array.isArray(fileCache) && fileCache.length > this._marketCache.length) {
+        this._marketCache = this.prepareMarketPlugins(fileCache);
+        return this._marketCache;
+      }
+      this._marketCache = this.prepareMarketPlugins(this._marketCache);
+      return this._marketCache;
+    }
+
+    if (!forceRefresh && Array.isArray(fileCache) && fileCache.length > 0) {
+      this._marketCache = this.prepareMarketPlugins(fileCache);
+      return this._marketCache;
     }
 
     const repos = this.getRepos().filter(r => r.enabled);
     const marketPlugins = [];
+    let repoFailureCount = 0;
 
     for (const repo of repos) {
       try {
@@ -1264,24 +1338,29 @@ class PluginsService {
           }
         }
       } catch (err) {
+        repoFailureCount++;
         console.error(`[PluginsService] Failed to fetch plugins from ${repo.owner}/${repo.name}:`, err.message);
       }
     }
 
-    // Mark installed plugins
-    const installedPlugins = this.listPlugins().plugins;
-    const installedNames = new Set(installedPlugins.map(p => p.name));
+    const preparedPlugins = this.prepareMarketPlugins(marketPlugins);
+    const preparedFileCache = Array.isArray(fileCache) && fileCache.length > 0
+      ? this.prepareMarketPlugins(fileCache)
+      : null;
+    const shouldUseStaleFileCache = preparedFileCache && (
+      (repos.length > 0 && repoFailureCount === repos.length) ||
+      (repoFailureCount > 0 && preparedFileCache.length > preparedPlugins.length)
+    );
 
-    marketPlugins.forEach(plugin => {
-      plugin.isInstalled = installedNames.has(plugin.name);
-    });
+    if (shouldUseStaleFileCache) {
+      this._marketCache = preparedFileCache;
+      return this._marketCache;
+    }
 
-    this._marketCache = marketPlugins;
-    try {
-      fs.writeFileSync(this.marketCachePath, JSON.stringify({ plugins: marketPlugins }), 'utf-8');
-    } catch (err) { /* ignore */ }
+    this._marketCache = preparedPlugins;
+    this.saveMarketCacheToFile(preparedPlugins);
 
-    return marketPlugins;
+    return preparedPlugins;
   }
 }
 

package/src/server/services/prompts-service.js

@@ -7,14 +7,13 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { NATIVE_PATHS } = require('../../config/paths');
+const { NATIVE_PATHS, PATHS } = require('../../config/paths');
 const { resolvePreferredHomeDir } = require('../../utils/home-dir');
 
 const HOME_DIR = resolvePreferredHomeDir(process.platform, process.env, os.homedir());
 
 // Prompts 配置文件路径
-const CC_TOOL_DIR = path.join(HOME_DIR, '.cc-tool');
-const PROMPTS_FILE = path.join(CC_TOOL_DIR, 'prompts.json');
+const PROMPTS_FILE = PATHS.prompts;
 
 // 各平台提示词文件路径
 const CLAUDE_PROMPT_PATH = path.join(HOME_DIR, '.claude', 'CLAUDE.md');

package/src/server/services/proxy-log-helper.js

@@ -0,0 +1,242 @@
+function toNumber(value) {
+  const num = Number(value);
+  return Number.isFinite(num) ? num : 0;
+}
+
+function normalizeToolSource(source = '') {
+  const normalized = String(source || '').trim().toLowerCase();
+  if (normalized === 'claude' || normalized === 'claude-code') return 'claude';
+  if (normalized === 'codex') return 'codex';
+  if (normalized === 'gemini') return 'gemini';
+  if (normalized === 'opencode') return 'opencode';
+  return 'claude';
+}
+
+function normalizeUsageTokens(source, tokens = {}) {
+  const normalizedSource = normalizeToolSource(source);
+  const input = toNumber(tokens.input);
+  const output = toNumber(tokens.output);
+  const cacheCreation = toNumber(tokens.cacheCreation);
+  const cacheRead = toNumber(tokens.cacheRead);
+  const cached = toNumber(tokens.cached);
+  const reasoning = toNumber(tokens.reasoning);
+  let total = toNumber(tokens.total);
+
+  if (total <= 0) {
+    if (normalizedSource === 'claude') {
+      total = input + output + cacheCreation + cacheRead;
+    } else {
+      total = input + output;
+    }
+  }
+
+  return {
+    input,
+    output,
+    cacheCreation,
+    cacheRead,
+    cached,
+    reasoning,
+    total
+  };
+}
+
+function hasMeaningfulUsage(source, tokens = {}) {
+  const normalized = normalizeUsageTokens(source, tokens);
+  if (normalized.total > 0) return true;
+  if (normalized.input > 0 || normalized.output > 0) return true;
+  if (normalized.cacheCreation > 0 || normalized.cacheRead > 0) return true;
+  if (normalized.cached > 0 || normalized.reasoning > 0) return true;
+  return false;
+}
+
+function formatRealtimeTime(timestamp = Date.now()) {
+  return new Date(timestamp).toLocaleTimeString('zh-CN', {
+    hour12: false,
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit'
+  });
+}
+
+function buildSuccessLogPayload({
+  source,
+  requestId,
+  channel,
+  model,
+  tokens,
+  cost = 0,
+  timestamp = Date.now()
+}) {
+  const normalized = normalizeUsageTokens(source, tokens);
+  return {
+    type: 'log',
+    status: 'success',
+    id: requestId,
+    time: formatRealtimeTime(timestamp),
+    channel,
+    model: model || '',
+    inputTokens: normalized.input,
+    outputTokens: normalized.output,
+    cacheCreation: normalized.cacheCreation,
+    cacheRead: normalized.cacheRead,
+    cachedTokens: normalized.cached,
+    reasoningTokens: normalized.reasoning,
+    totalTokens: normalized.total,
+    cost,
+    source: normalizeToolSource(source),
+    timestamp
+  };
+}
+
+function buildFailureLogPayload({
+  source,
+  requestId,
+  channel,
+  model,
+  message,
+  error,
+  statusCode,
+  stage,
+  timestamp = Date.now()
+}) {
+  const errorMessage = String(
+    error?.message
+    || message
+    || error
+    || 'Request failed'
+  );
+
+  return {
+    type: 'log',
+    status: 'error',
+    id: requestId || `${normalizeToolSource(source)}-error-${timestamp}-${Math.random().toString(36).slice(2, 8)}`,
+    time: formatRealtimeTime(timestamp),
+    channel: channel || 'Unknown',
+    model: model || '',
+    message: errorMessage,
+    error: errorMessage,
+    statusCode: Number.isFinite(Number(statusCode)) ? Number(statusCode) : null,
+    stage: stage || 'proxy',
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheCreation: 0,
+    cacheRead: 0,
+    cachedTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+    cost: 0,
+    source: normalizeToolSource(source),
+    timestamp
+  };
+}
+
+function publishUsageLog({
+  source,
+  metadata = {},
+  model,
+  tokens,
+  calculateCost,
+  broadcastLog,
+  recordRequest,
+  recordSuccess,
+  allowBroadcast = true
+}) {
+  if (!hasMeaningfulUsage(source, tokens)) {
+    return null;
+  }
+
+  const normalizedSource = normalizeToolSource(source);
+  const normalizedTokens = normalizeUsageTokens(normalizedSource, tokens);
+  const requestId = metadata.id || `${normalizedSource}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  const timestamp = Date.now();
+  const cost = typeof calculateCost === 'function'
+    ? calculateCost(model || '', normalizedTokens)
+    : 0;
+
+  if (allowBroadcast && typeof broadcastLog === 'function') {
+    broadcastLog(buildSuccessLogPayload({
+      source: normalizedSource,
+      requestId,
+      channel: metadata.channel,
+      model,
+      tokens: normalizedTokens,
+      cost,
+      timestamp
+    }));
+  }
+
+  if (typeof recordRequest === 'function') {
+    recordRequest({
+      id: requestId,
+      timestamp: new Date(metadata.startTime || timestamp).toISOString(),
+      toolType: normalizedSource === 'claude' ? 'claude-code' : normalizedSource,
+      channel: metadata.channel,
+      channelId: metadata.channelId,
+      model: model || '',
+      tokens: {
+        input: normalizedTokens.input,
+        output: normalizedTokens.output,
+        reasoning: normalizedTokens.reasoning,
+        cached: normalizedTokens.cached,
+        cacheCreation: normalizedTokens.cacheCreation,
+        cacheRead: normalizedTokens.cacheRead,
+        total: normalizedTokens.total
+      },
+      duration: Math.max(0, timestamp - toNumber(metadata.startTime || timestamp)),
+      success: true,
+      cost
+    });
+  }
+
+  if (typeof recordSuccess === 'function' && metadata.channelId) {
+    recordSuccess(metadata.channelId, normalizedSource);
+  }
+
+  return {
+    cost,
+    tokens: normalizedTokens,
+    timestamp
+  };
+}
+
+function publishFailureLog({
+  source,
+  metadata = {},
+  channel,
+  model,
+  message,
+  error,
+  statusCode,
+  stage,
+  broadcastLog
+}) {
+  if (typeof broadcastLog !== 'function') {
+    return null;
+  }
+
+  const payload = buildFailureLogPayload({
+    source,
+    requestId: metadata.id,
+    channel: channel || metadata.channel,
+    model: model || metadata.model,
+    message,
+    error,
+    statusCode,
+    stage
+  });
+  broadcastLog(payload);
+  return payload;
+}
+
+module.exports = {
+  toNumber,
+  normalizeToolSource,
+  normalizeUsageTokens,
+  hasMeaningfulUsage,
+  formatRealtimeTime,
+  buildSuccessLogPayload,
+  buildFailureLogPayload,
+  publishUsageLog,
+  publishFailureLog
+};

package/src/server/services/proxy-runtime.js

@@ -3,11 +3,13 @@ const path = require('path');
 const { PATHS } = require('../../config/paths');
 
 function getRuntimeFilePath(proxyType) {
-  const ccToolDir = PATHS.base;
-  if (!fs.existsSync(ccToolDir)) {
-    fs.mkdirSync(ccToolDir, { recursive: true });
+  const filePath = PATHS.proxyRuntime?.[proxyType]
+    || path.join(path.dirname(PATHS.proxyRuntime.claude), `${proxyType}-proxy.json`);
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
-  return path.join(ccToolDir, `${proxyType}-proxy-runtime.json`);
+  return filePath;
 }
 
 function saveProxyStartTime(proxyType, preserveExisting = false) {

package/src/server/services/repo-scanner-base.js

@@ -11,7 +11,7 @@ const https = require('https');
 const http = require('http');
 const { createWriteStream } = require('fs');
 const AdmZip = require('adm-zip');
-const { HOME_DIR } = require('../../config/paths');
+const { PATHS, getRepoScannerReposPath, getRepoScannerCachePath } = require('../../config/paths');
 
 // 缓存有效期（5分钟）
 const CACHE_TTL = 5 * 60 * 1000;
@@ -70,9 +70,9 @@ class RepoScannerBase {
     this.fileExtension = options.fileExtension || '.md';
     this.defaultRepos = options.defaultRepos || [];
 
-    this.configDir = path.join(HOME_DIR, '.cc-tool');
-    this.reposConfigPath = path.join(this.configDir, `${this.type}-repos.json`);
-    this.cachePath = path.join(this.configDir, `${this.type}-cache.json`);
+    this.configDir = PATHS.config;
+    this.reposConfigPath = getRepoScannerReposPath(this.type);
+    this.cachePath = getRepoScannerCachePath(this.type);
 
     // 内存缓存
     this.itemsCache = null;
@@ -89,6 +89,14 @@ class RepoScannerBase {
     if (!fs.existsSync(this.configDir)) {
       fs.mkdirSync(this.configDir, { recursive: true });
     }
+    const reposDir = path.dirname(this.reposConfigPath);
+    if (!fs.existsSync(reposDir)) {
+      fs.mkdirSync(reposDir, { recursive: true });
+    }
+    const cacheDir = path.dirname(this.cachePath);
+    if (!fs.existsSync(cacheDir)) {
+      fs.mkdirSync(cacheDir, { recursive: true });
+    }
   }
 
   // ==================== 仓库配置管理 ====================

package/src/server/services/request-logger.js

@@ -18,7 +18,7 @@ const fs = require('fs');
 const path = require('path');
 const { PATHS } = require('../../config/paths');
 
-const CC_TOOL_DIR = PATHS.base;
+const REQUEST_SNAPSHOTS_DIR = path.dirname(PATHS.requestSnapshots.claude);
 
 function ensureDir(dir) {
   if (!fs.existsSync(dir)) {
@@ -55,8 +55,8 @@ function persistProxyRequestSnapshot(source, payload) {
   if (!isProxyRequestLoggingEnabled()) return;
 
   try {
-    ensureDir(CC_TOOL_DIR);
-    const logPath = path.join(CC_TOOL_DIR, `${source}-requests.jsonl`);
+    const logPath = PATHS.requestSnapshots[source] || path.join(REQUEST_SNAPSHOTS_DIR, `${source}.jsonl`);
+    ensureDir(path.dirname(logPath));
     fs.appendFile(logPath, `${JSON.stringify(payload)}\n`, (error) => {
       if (error) {
         console.error(`[request-logger] Failed to persist ${source} request snapshot:`, error);
@@ -97,8 +97,8 @@ function createApiRequestLogger() {
       };
 
       try {
-        ensureDir(path.join(CC_TOOL_DIR, 'logs'));
-        const logPath = path.join(CC_TOOL_DIR, 'logs', 'api-requests.jsonl');
+        ensureDir(PATHS.logs);
+        const logPath = path.join(PATHS.logs, 'api-requests.jsonl');
         fs.appendFile(logPath, `${JSON.stringify(entry)}\n`, (err) => {
           if (err) {
             console.error('[request-logger] Failed to write API request log:', err);
@@ -122,7 +122,7 @@ function createApiRequestLogger() {
   };
 }
 
-const CLAUDE_TEMPLATE_PATH = path.join(CC_TOOL_DIR, 'claude-request-template.json');
+const CLAUDE_TEMPLATE_PATH = PATHS.claudeRequestTemplate;
 const CLAUDE_TEMPLATE_MIN_SYSTEM_CHARS = 100;
 
 const FALLBACK_CLAUDE_SYSTEM = Object.freeze([
@@ -280,7 +280,7 @@ function persistClaudeRequestTemplate(body) {
   if (systemCharCount < CLAUDE_TEMPLATE_MIN_SYSTEM_CHARS) return;
 
   try {
-    ensureDir(CC_TOOL_DIR);
+    ensureDir(path.dirname(CLAUDE_TEMPLATE_PATH));
     const template = { updatedAt: Date.now(), userId, system, tools };
     fs.writeFile(CLAUDE_TEMPLATE_PATH, JSON.stringify(template), (err) => {
       if (err) console.error('[request-logger] Failed to write claude-request-template.json:', err);

package/src/server/services/security-config.js

@@ -3,8 +3,7 @@ const path = require('path');
 const crypto = require('crypto');
 const { PATHS } = require('../../config/paths');
 
-const SECURITY_DIR = PATHS.base;
-const SECURITY_FILE = path.join(SECURITY_DIR, 'security.json');
+const SECURITY_FILE = PATHS.security;
 
 const DEFAULT_SECURITY_CONFIG = {
   passwordHash: '',
@@ -17,8 +16,9 @@ const PBKDF2_KEYLEN = 64;
 const PBKDF2_DIGEST = 'sha512';
 
 function ensureSecurityDir() {
-  if (!fs.existsSync(SECURITY_DIR)) {
-    fs.mkdirSync(SECURITY_DIR, { recursive: true });
+  const dir = path.dirname(SECURITY_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
   }
 }