@afffun/codexbot 1.0.71

package/README.md

@@ -0,0 +1,14 @@
+# Codexbot npm CLI
+
+This package is the thin npm-distributed entrypoint for Codexbot.
+
+It does not embed the full runtime payload, systemd units, or native sidecars.
+Instead it exposes explicit commands such as:
+
+- `codexbot install`
+- `codexbot upgrade`
+- `codexbot auth status`
+- `codexbot auth login`
+
+`install` and `upgrade` fetch the signed release package through the existing
+Codexbot update pipeline, then apply it with the official installer.

package/bin/codexbot.mjs

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+
+import { runCodexbotCli } from '../src/entrypoint.mjs';
+
+const exitCode = await runCodexbotCli(process.argv.slice(2));
+process.exit(exitCode);

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@afffun/codexbot",
+  "version": "1.0.71",
+  "description": "Thin npm bootstrap CLI for installing and operating Codexbot nodes",
+  "type": "module",
+  "author": "john88188 <john88188@outlook.com>",
+  "license": "ISC",
+  "bin": {
+    "codexbot": "./bin/codexbot.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  }
+}

package/src/args_service.mjs

@@ -0,0 +1,147 @@
+function trim(value) {
+  return String(value ?? '').trim();
+}
+
+function readOptionValue(argv, index, name) {
+  if (index + 1 >= argv.length) {
+    throw new Error(`missing value for ${name}`);
+  }
+  return String(argv[index + 1] || '').trim();
+}
+
+function parseBootstrapOptions(argv = []) {
+  const options = {
+    channel: '',
+    updateBaseUrl: '',
+    manifestUrl: '',
+    publicKeyUrl: '',
+    installRemoteUrl: '',
+    publicKeyFile: '',
+    token: '',
+    allowHttp: false,
+    noSignature: false,
+    forwardedArgs: [],
+  };
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = trim(argv[i]);
+    if (!token) continue;
+    if (token === '--channel') {
+      options.channel = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--update-base-url') {
+      options.updateBaseUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--manifest-url') {
+      options.manifestUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--public-key-url') {
+      options.publicKeyUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--install-remote-url') {
+      options.installRemoteUrl = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--public-key-file') {
+      options.publicKeyFile = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--token' || token === '--auth-token') {
+      options.token = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--allow-http') {
+      options.allowHttp = true;
+      options.forwardedArgs.push(token);
+      continue;
+    }
+    if (token === '--no-signature') {
+      options.noSignature = true;
+      options.forwardedArgs.push(token);
+      continue;
+    }
+    options.forwardedArgs.push(token);
+  }
+
+  return options;
+}
+
+function parseAuthOptions(argv = []) {
+  const options = {
+    layoutProfile: '',
+    appDir: '',
+    controlEnvFile: '',
+    controlUser: '',
+    codexHomeDir: '',
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const token = trim(argv[i]);
+    if (!token) continue;
+    if (token === '--layout-profile') {
+      options.layoutProfile = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--app-dir') {
+      options.appDir = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--control-env-file') {
+      options.controlEnvFile = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--control-user') {
+      options.controlUser = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    if (token === '--codex-home-dir') {
+      options.codexHomeDir = readOptionValue(argv, i, token);
+      i += 1;
+      continue;
+    }
+    throw new Error(`unknown auth arg: ${token}`);
+  }
+  return options;
+}
+
+export function parseCliArgs(argv = []) {
+  const args = Array.isArray(argv) ? argv.map((item) => String(item || '')) : [];
+  const command = trim(args[0]).toLowerCase();
+  if (!command || command === 'help' || command === '--help' || command === '-h') {
+    return { action: 'help' };
+  }
+  if (command === 'version' || command === '--version' || command === '-v') {
+    return { action: 'version' };
+  }
+  if (command === 'doctor') {
+    return { action: 'doctor', options: parseAuthOptions(args.slice(1)) };
+  }
+  if (command === 'install') {
+    return { action: 'install', options: parseBootstrapOptions(args.slice(1)) };
+  }
+  if (command === 'upgrade') {
+    return { action: 'upgrade', options: parseBootstrapOptions(args.slice(1)) };
+  }
+  if (command === 'auth') {
+    const sub = trim(args[1]).toLowerCase() || 'status';
+    if (!['status', 'login', 'login-link', 'logout'].includes(sub)) {
+      throw new Error(`unknown auth subcommand: ${sub}`);
+    }
+    return { action: 'auth', mode: sub, options: parseAuthOptions(args.slice(2)) };
+  }
+  throw new Error(`unknown command: ${command}`);
+}

package/src/auth_service.mjs

@@ -0,0 +1,111 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { resolveInstalledControlLayout } from './installed_layout_service.mjs';
+
+function runChild(spawnFn, command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, {
+      stdio: 'inherit',
+      ...options,
+    });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited via signal ${signal}`));
+        return;
+      }
+      resolve(Number(code || 0));
+    });
+  });
+}
+
+function trim(value, fallback = '') {
+  const text = String(value ?? '').trim();
+  return text || String(fallback ?? '').trim();
+}
+
+function mapAuthModeToCodexArgs(mode) {
+  if (mode === 'status') return ['login', 'status'];
+  if (mode === 'login') return ['login', '--device-auth'];
+  if (mode === 'login-link') return ['login'];
+  if (mode === 'logout') return ['logout'];
+  throw new Error(`unsupported auth mode: ${mode}`);
+}
+
+export function createNpmDistributionAuthService(deps = {}) {
+  const fsSync = deps.fsSync || fs;
+  const pathModule = deps.pathModule || path;
+  const spawnFn = deps.spawnFn || spawn;
+  const processImpl = deps.processImpl || process;
+  const logger = deps.logger || console;
+
+  function resolveControlLayout(options = {}) {
+    const layout = resolveInstalledControlLayout({
+      fsSync,
+      pathModule,
+      env: processImpl.env,
+      profile: options.layoutProfile,
+      appDir: options.appDir,
+      controlEnvFile: options.controlEnvFile,
+      controlUser: options.controlUser,
+      codexHomeDir: options.codexHomeDir,
+    });
+    if (!fsSync.existsSync(layout.codexBinPath)) {
+      throw new Error(`installed codex binary not found: ${layout.codexBinPath}`);
+    }
+    return layout;
+  }
+
+  async function runAuthCommand(mode, options = {}) {
+    const layout = resolveControlLayout(options);
+    const codexArgs = mapAuthModeToCodexArgs(mode);
+    const currentUser = trim(layout.currentUser, trim(processImpl.env.USER || processImpl.env.LOGNAME, ''));
+    const isRoot = typeof processImpl.getuid === 'function' ? processImpl.getuid() === 0 : false;
+    const envArgs = ['env', `CODEX_HOME=${layout.codexHomeDir}`, `PATH=${pathModule.dirname(layout.codexBinPath)}:${processImpl.env.PATH || ''}`, layout.codexBinPath, ...codexArgs];
+    logger.log(`==> Run Codex auth command for ${layout.profile} install as ${layout.controlUser}`);
+    if (isRoot) {
+      return runChild(spawnFn, 'sudo', ['-u', layout.controlUser, ...envArgs]);
+    }
+    if (currentUser && currentUser === layout.controlUser) {
+      return runChild(spawnFn, layout.codexBinPath, codexArgs, {
+        env: {
+          ...processImpl.env,
+          CODEX_HOME: layout.codexHomeDir,
+          PATH: `${pathModule.dirname(layout.codexBinPath)}:${processImpl.env.PATH || ''}`,
+        },
+      });
+    }
+    return runChild(spawnFn, 'sudo', ['-u', layout.controlUser, ...envArgs]);
+  }
+
+  function formatDoctorReport(options = {}) {
+    const layout = resolveControlLayout(options);
+    return [
+      `profile: ${layout.profile}`,
+      `app_dir: ${layout.appDir}`,
+      `control_env_file: ${layout.controlEnvFile}`,
+      `control_user: ${layout.controlUser}`,
+      `codex_home: ${layout.codexHomeDir}`,
+      `codex_bin: ${layout.codexBinPath}`,
+    ].join('\n');
+  }
+
+  function resolveInstalledVersion(options = {}) {
+    const layout = resolveControlLayout(options);
+    const packageJsonPath = pathModule.join(layout.appDir, 'package.json');
+    if (!fsSync.existsSync(packageJsonPath)) return '';
+    try {
+      const pkg = JSON.parse(fsSync.readFileSync(packageJsonPath, 'utf8'));
+      return String(pkg.version || '').trim();
+    } catch {
+      return '';
+    }
+  }
+
+  return {
+    runAuthCommand,
+    formatDoctorReport,
+    resolveInstalledVersion,
+  };
+}

package/src/config_service.mjs

@@ -0,0 +1,62 @@
+const DEFAULT_UPDATE_BASE_URL = 'https://codexbotupdate.afffun.com';
+const DEFAULT_CHANNEL = 'stable';
+
+function trim(value, fallback = '') {
+  const text = String(value ?? '').trim();
+  return text || String(fallback ?? '').trim();
+}
+
+function normalizeBaseUrl(value, fallback = DEFAULT_UPDATE_BASE_URL) {
+  return trim(value, fallback).replace(/\/+$/g, '');
+}
+
+function normalizeChannel(value, fallback = DEFAULT_CHANNEL) {
+  const text = trim(value, fallback);
+  if (!/^[a-zA-Z0-9._-]+$/.test(text)) {
+    throw new Error(`invalid channel: ${text}`);
+  }
+  return text;
+}
+
+function assertHttps(value, { allowHttp = false, label = 'url' } = {}) {
+  const url = new URL(String(value || '').trim());
+  if (!allowHttp && url.protocol !== 'https:') {
+    throw new Error(`${label} must use https unless --allow-http is set`);
+  }
+  return url.toString();
+}
+
+export function getDefaultDistributionConfig(env = process.env) {
+  return {
+    updateBaseUrl: normalizeBaseUrl(env.CODEXBOT_UPDATE_BASE_URL, DEFAULT_UPDATE_BASE_URL),
+    channel: normalizeChannel(env.CODEXBOT_INSTALL_CHANNEL, DEFAULT_CHANNEL),
+    authToken: trim(env.CODEXBOT_UPDATE_TOKEN || env.CODEX_REMOTE_UPDATE_AUTH_TOKEN, ''),
+  };
+}
+
+export function buildRemoteInstallUrls({
+  updateBaseUrl = DEFAULT_UPDATE_BASE_URL,
+  channel = DEFAULT_CHANNEL,
+  manifestUrl = '',
+  publicKeyUrl = '',
+  installRemoteUrl = '',
+  allowHttp = false,
+} = {}) {
+  const resolvedBaseUrl = normalizeBaseUrl(updateBaseUrl, DEFAULT_UPDATE_BASE_URL);
+  const resolvedChannel = normalizeChannel(channel, DEFAULT_CHANNEL);
+  const root = `${resolvedBaseUrl}/v1/channels/${resolvedChannel}`;
+  const urls = {
+    updateBaseUrl: resolvedBaseUrl,
+    channel: resolvedChannel,
+    manifestUrl: trim(manifestUrl) || `${root}/manifest.json`,
+    publicKeyUrl: trim(publicKeyUrl) || `${root}/packages/latest/update-public.pem`,
+    installRemoteUrl: trim(installRemoteUrl) || `${root}/packages/latest/install-remote.sh`,
+  };
+  return {
+    updateBaseUrl: assertHttps(urls.updateBaseUrl, { allowHttp, label: 'update base url' }),
+    channel: urls.channel,
+    manifestUrl: assertHttps(urls.manifestUrl, { allowHttp, label: 'manifest url' }),
+    publicKeyUrl: assertHttps(urls.publicKeyUrl, { allowHttp, label: 'public key url' }),
+    installRemoteUrl: assertHttps(urls.installRemoteUrl, { allowHttp, label: 'install-remote url' }),
+  };
+}

package/src/entrypoint.mjs

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseCliArgs } from './args_service.mjs';
+import { createNpmDistributionInstallService } from './install_service.mjs';
+import { createNpmDistributionAuthService } from './auth_service.mjs';
+
+function readPackageVersion() {
+  const packageJsonPath = new URL('../package.json', import.meta.url);
+  const raw = fs.readFileSync(packageJsonPath, 'utf8');
+  const pkg = JSON.parse(raw);
+  return String(pkg.version || '').trim();
+}
+
+function renderUsage() {
+  return [
+    'Usage:',
+    '  codexbot install [bootstrap options] [install-remote flags...]',
+    '  codexbot upgrade [bootstrap options] [install-remote flags...]',
+    '  codexbot auth status|login|login-link|logout [layout overrides]',
+    '  codexbot doctor [layout overrides]',
+    '  codexbot version',
+    '',
+    'Bootstrap options:',
+    '  --channel <stable|canary|...>',
+    '  --update-base-url <https://codexbotupdate.example.com>',
+    '  --manifest-url <url>',
+    '  --public-key-url <url>',
+    '  --install-remote-url <url>',
+    '  --public-key-file </path/to/update-public.pem>',
+    '  --token <update server token>',
+    '  --allow-http',
+    '',
+    'Layout overrides:',
+    '  --layout-profile <split|legacy>',
+    '  --app-dir <path>',
+    '  --control-env-file <path>',
+    '  --control-user <user>',
+    '  --codex-home-dir <path>',
+  ].join('\n');
+}
+
+export async function runCodexbotCli(argv = [], deps = {}) {
+  const logger = deps.logger || console;
+  const installService = deps.installService || createNpmDistributionInstallService({ logger });
+  const authService = deps.authService || createNpmDistributionAuthService({ logger });
+  const cli = parseCliArgs(argv);
+  if (cli.action === 'help') {
+    logger.log(renderUsage());
+    return 0;
+  }
+  if (cli.action === 'version') {
+    const packageVersion = readPackageVersion();
+    let installedVersion = '';
+    try {
+      installedVersion = authService.resolveInstalledVersion({});
+    } catch {
+      installedVersion = '';
+    }
+    logger.log(installedVersion
+      ? `codexbot npm cli ${packageVersion}\ninstalled runtime ${installedVersion}`
+      : `codexbot npm cli ${packageVersion}`);
+    return 0;
+  }
+  if (cli.action === 'doctor') {
+    logger.log(authService.formatDoctorReport(cli.options || {}));
+    return 0;
+  }
+  if (cli.action === 'install') {
+    return installService.runInstallCommand(cli.options || {});
+  }
+  if (cli.action === 'upgrade') {
+    return installService.runUpgradeCommand(cli.options || {});
+  }
+  if (cli.action === 'auth') {
+    return authService.runAuthCommand(cli.mode, cli.options || {});
+  }
+  throw new Error(`unsupported action: ${cli.action}`);
+}

package/src/env_file_service.mjs

@@ -0,0 +1,26 @@
+function stripWrappingQuotes(value) {
+  const text = String(value ?? '');
+  if (text.length >= 2) {
+    const first = text[0];
+    const last = text[text.length - 1];
+    if ((first === '"' && last === '"') || (first === '\'' && last === '\'')) {
+      return text.slice(1, -1);
+    }
+  }
+  return text;
+}
+
+export function parseEnvText(text = '') {
+  const out = {};
+  for (const rawLine of String(text || '').split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    const index = line.indexOf('=');
+    if (index <= 0) continue;
+    const key = line.slice(0, index).trim();
+    if (!key) continue;
+    const value = stripWrappingQuotes(line.slice(index + 1).trim());
+    out[key] = value;
+  }
+  return out;
+}

package/src/install_service.mjs

@@ -0,0 +1,108 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { buildRemoteInstallUrls, getDefaultDistributionConfig } from './config_service.mjs';
+
+function trim(value, fallback = '') {
+  const text = String(value ?? '').trim();
+  return text || String(fallback ?? '').trim();
+}
+
+async function ensureOkResponse(response, label) {
+  if (!response.ok) {
+    throw new Error(`${label} download failed: ${response.status} ${response.statusText}`);
+  }
+  return response;
+}
+
+async function writeResponseToFile(response, filePath, fsPromises) {
+  const buffer = Buffer.from(await response.arrayBuffer());
+  await fsPromises.writeFile(filePath, buffer);
+}
+
+function runChild(spawnFn, command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawnFn(command, args, {
+      stdio: 'inherit',
+      ...options,
+    });
+    child.on('error', reject);
+    child.on('exit', (code, signal) => {
+      if (signal) {
+        reject(new Error(`${command} exited via signal ${signal}`));
+        return;
+      }
+      resolve(Number(code || 0));
+    });
+  });
+}
+
+export function createNpmDistributionInstallService(deps = {}) {
+  const fetchFn = deps.fetchFn || fetch;
+  const fsPromises = deps.fsPromises || fs;
+  const osModule = deps.osModule || os;
+  const pathModule = deps.pathModule || path;
+  const spawnFn = deps.spawnFn || spawn;
+  const processImpl = deps.processImpl || process;
+  const logger = deps.logger || console;
+
+  async function runRemoteInstall({
+    mode,
+    options = {},
+  } = {}) {
+    const defaults = getDefaultDistributionConfig(processImpl.env);
+    const urls = buildRemoteInstallUrls({
+      updateBaseUrl: options.updateBaseUrl || defaults.updateBaseUrl,
+      channel: options.channel || defaults.channel,
+      manifestUrl: options.manifestUrl,
+      publicKeyUrl: options.publicKeyUrl,
+      installRemoteUrl: options.installRemoteUrl,
+      allowHttp: Boolean(options.allowHttp),
+    });
+    const authToken = trim(options.token, defaults.authToken);
+    const tempDir = await fsPromises.mkdtemp(pathModule.join(osModule.tmpdir(), 'codexbot-npm-'));
+    const tempInstallPath = pathModule.join(tempDir, 'install-remote.sh');
+    const tempKeyPath = pathModule.join(tempDir, 'update-public.pem');
+    const headers = authToken ? { Authorization: `Bearer ${authToken}` } : {};
+    try {
+      logger.log(`==> Fetch install entry from ${urls.installRemoteUrl}`);
+      const installResponse = await ensureOkResponse(await fetchFn(urls.installRemoteUrl, { headers }), 'install-remote');
+      await writeResponseToFile(installResponse, tempInstallPath, fsPromises);
+      await fsPromises.chmod(tempInstallPath, 0o755);
+
+      const publicKeyFile = trim(options.publicKeyFile, '');
+      const resolvedPublicKeyFile = publicKeyFile || tempKeyPath;
+      if (!publicKeyFile) {
+        logger.log(`==> Fetch update public key from ${urls.publicKeyUrl}`);
+        const keyResponse = await ensureOkResponse(await fetchFn(urls.publicKeyUrl, { headers }), 'update public key');
+        await writeResponseToFile(keyResponse, tempKeyPath, fsPromises);
+      }
+
+      const args = [
+        tempInstallPath,
+        '--manifest-url', urls.manifestUrl,
+        '--public-key-file', resolvedPublicKeyFile,
+        '--channel', urls.channel,
+        '--mode', trim(mode, 'auto'),
+        ...(authToken ? ['--auth-token', authToken] : []),
+        ...(Array.isArray(options.forwardedArgs) ? options.forwardedArgs : []),
+      ];
+      const isRoot = typeof processImpl.getuid === 'function' ? processImpl.getuid() === 0 : false;
+      const command = isRoot ? 'bash' : 'sudo';
+      const commandArgs = isRoot ? args : ['bash', ...args];
+      return await runChild(spawnFn, command, commandArgs);
+    } finally {
+      await fsPromises.rm(tempDir, { recursive: true, force: true }).catch(() => {});
+    }
+  }
+
+  return {
+    runInstallCommand(options = {}) {
+      return runRemoteInstall({ mode: 'install', options });
+    },
+    runUpgradeCommand(options = {}) {
+      return runRemoteInstall({ mode: 'upgrade', options });
+    },
+  };
+}

package/src/installed_layout_service.mjs

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { parseEnvText } from './env_file_service.mjs';
+
+const SPLIT_DEFAULTS = Object.freeze({
+  profile: 'split',
+  appDir: '/usr/local/lib/codexbot',
+  controlEnvFile: '/etc/codexbot/control.env',
+  controlUser: 'codexbotd',
+  codexHomeDir: '/var/lib/codexbot/control/home/.codex',
+});
+
+const LEGACY_DEFAULTS = Object.freeze({
+  profile: 'legacy',
+  appDir: '/home/codexbot/codexbot-telegram',
+  controlEnvFile: '/home/codexbot/codexbot-telegram/.env',
+  controlUser: 'codexbot',
+  codexHomeDir: '/home/codexbot/codexbot-home/.codex',
+});
+
+function trim(value, fallback = '') {
+  const text = String(value ?? '').trim();
+  return text || String(fallback ?? '').trim();
+}
+
+function exists(fsSync, target) {
+  try {
+    return fsSync.existsSync(target);
+  } catch {
+    return false;
+  }
+}
+
+function readEnvFile(fsSync, filePath) {
+  try {
+    if (!exists(fsSync, filePath)) return {};
+    return parseEnvText(fsSync.readFileSync(filePath, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function resolveProfile(fsSync, explicitProfile, explicitEnvFile) {
+  const profile = trim(explicitProfile).toLowerCase();
+  if (profile === 'split' || profile === 'legacy') return profile;
+  if (trim(explicitEnvFile).endsWith('/control.env')) return 'split';
+  if (trim(explicitEnvFile).endsWith('/.env')) return 'legacy';
+  if (exists(fsSync, SPLIT_DEFAULTS.controlEnvFile) || exists(fsSync, SPLIT_DEFAULTS.appDir)) return 'split';
+  return 'legacy';
+}
+
+export function resolveInstalledControlLayout({
+  fsSync = fs,
+  pathModule = path,
+  env = process.env,
+  profile = '',
+  appDir = '',
+  controlEnvFile = '',
+  controlUser = '',
+  codexHomeDir = '',
+} = {}) {
+  const resolvedProfile = resolveProfile(fsSync, profile, controlEnvFile);
+  const defaults = resolvedProfile === 'split' ? SPLIT_DEFAULTS : LEGACY_DEFAULTS;
+  const envFile = trim(controlEnvFile, defaults.controlEnvFile);
+  const fileEnv = readEnvFile(fsSync, envFile);
+  const resolvedAppDir = pathModule.resolve(trim(appDir || fileEnv.CODEXBOT_APP_DIR || fileEnv.CODEXBOT_SYSTEM_ROOT, defaults.appDir));
+  const resolvedControlUser = trim(controlUser || fileEnv.CODEXBOT_CONTROL_USER, defaults.controlUser);
+  const resolvedCodexHomeDir = pathModule.resolve(trim(
+    codexHomeDir
+      || fileEnv.CODEXBOT_CONTROL_CODEX_HOME_DIR
+      || fileEnv.CODEX_HOME
+      || fileEnv.CODEXBOT_CONTROL_HOME && `${fileEnv.CODEXBOT_CONTROL_HOME}/.codex`,
+    defaults.codexHomeDir,
+  ));
+  const codexBinPath = pathModule.join(resolvedAppDir, 'node_modules', '.bin', 'codex');
+  return {
+    profile: resolvedProfile,
+    appDir: resolvedAppDir,
+    controlEnvFile: envFile,
+    controlUser: resolvedControlUser,
+    codexHomeDir: resolvedCodexHomeDir,
+    codexBinPath,
+    env: fileEnv,
+    currentUser: trim(env.USER || env.LOGNAME || ''),
+  };
+}