coding-tool-x 3.3.7 → 3.3.9

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

@@ -0,0 +1,423 @@
+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,
+    envFilePath,
+    stateFilePath,
+    shellEnv,
+    execSync
+  } = options;
+  const { preferred, candidates } = getPosixProfileCandidates(homeDir, shellEnv);
+  const nextKeys = Object.keys(nextValues).sort();
+  const previousProfiles = Array.isArray(previousState.profiles) ? previousState.profiles : [];
+  const managedProfiles = new Set(previousProfiles);
+  const sourceSnippet = buildSourceSnippet(envFilePath, homeDir);
+  let changed = false;
+
+  if (nextKeys.length > 0) {
+    const envContent = [
+      '# Managed by Coding-Tool for Codex env_key providers',
+      ...nextKeys.map(key => `export ${key}=${shellQuote(nextValues[key])}`),
+      ''
+    ].join('\n');
+    changed = writeTextFileIfChanged(envFilePath, envContent) || changed;
+
+    const existingProfiles = candidates.filter(filePath => fs.existsSync(filePath));
+    if (managedProfiles.size === 0) {
+      if (existingProfiles.length > 0) {
+        for (const profilePath of existingProfiles) {
+          managedProfiles.add(profilePath);
+        }
+      } else {
+        managedProfiles.add(preferred);
+      }
+    }
+
+    for (const profilePath of managedProfiles) {
+      const currentContent = fs.existsSync(profilePath) ? fs.readFileSync(profilePath, 'utf8') : '';
+      const nextContent = upsertManagedBlock(currentContent, sourceSnippet);
+      changed = writeTextFileIfChanged(profilePath, nextContent) || changed;
+    }
+  } else {
+    if (fs.existsSync(envFilePath)) {
+      fs.unlinkSync(envFilePath);
+      changed = true;
+    }
+
+    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');
+      const nextContent = stripManagedBlock(currentContent);
+      const finalContent = nextContent ? `${nextContent}\n` : '';
+      changed = writeTextFileIfChanged(profilePath, finalContent) || changed;
+    }
+    managedProfiles.clear();
+  }
+
+  for (const key of Object.keys(previousState.values || {})) {
+    if (!Object.prototype.hasOwnProperty.call(nextValues, key)) {
+      delete process.env[key];
+    }
+  }
+  for (const [key, value] of Object.entries(nextValues)) {
+    process.env[key] = value;
+  }
+
+  if (runtime === 'darwin') {
+    applyLaunchctlEnvironment(previousState.values || {}, nextValues, execSync);
+  }
+
+  if (nextKeys.length > 0) {
+    writeJsonFile(stateFilePath, {
+      version: 1,
+      values: nextValues,
+      profiles: Array.from(managedProfiles)
+    });
+  } else if (fs.existsSync(stateFilePath)) {
+    fs.unlinkSync(stateFilePath);
+  }
+
+  return {
+    changed,
+    reloadRequired: changed,
+    isFirstTime: Object.keys(previousState.values || {}).length === 0 && nextKeys.length > 0,
+    sourceCommand: nextKeys.length > 0 ? `source "${buildHomeRelativeShellPath(envFilePath, homeDir)}"` : null,
+    shellConfigPath: managedProfiles.size > 0 ? Array.from(managedProfiles)[0] : null,
+    shellConfigPaths: Array.from(managedProfiles),
+    envFilePath: nextKeys.length > 0 ? envFilePath : null,
+    managedKeys: nextKeys
+  };
+}
+
+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) {
+      process.env[key] = value;
+      continue;
+    }
+    setWindowsUserEnv(key, value, execSync);
+    process.env[key] = value;
+    changed = true;
+  }
+
+  for (const key of Object.keys(previousValues)) {
+    if (Object.prototype.hasOwnProperty.call(nextValues, key)) {
+      continue;
+    }
+    removeWindowsUserEnv(key, execSync);
+    delete process.env[key];
+    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
+  }
+};