@mseep/claudian 2.0.25

package/src/providers/codex/runtime/CodexCliResolver.ts

@@ -0,0 +1,65 @@
+import { getRuntimeEnvironmentText } from '../../../core/providers/providerEnvironment';
+import type { HostnameCliPaths } from '../../../core/types/settings';
+import { getHostnameKey } from '../../../utils/env';
+import type { CodexInstallationMethod } from '../settings';
+import { getCodexProviderSettings } from '../settings';
+import { resolveCodexCliPath } from './CodexBinaryLocator';
+
+export class CodexCliResolver {
+  private resolvedPath: string | null = null;
+  private lastHostnamePath = '';
+  private lastLegacyPath = '';
+  private lastEnvText = '';
+  private lastInstallationMethod = '';
+  private readonly cachedHostname = getHostnameKey();
+
+  resolveFromSettings(settings: Record<string, unknown>): string | null {
+    const codexSettings = getCodexProviderSettings(settings);
+    const hostnamePath = (codexSettings.cliPathsByHost[this.cachedHostname] ?? '').trim();
+    const legacyPath = codexSettings.cliPath.trim();
+    const envText = getRuntimeEnvironmentText(settings, 'codex');
+    const installationMethod = codexSettings.installationMethod;
+
+    if (
+      this.resolvedPath &&
+      hostnamePath === this.lastHostnamePath &&
+      legacyPath === this.lastLegacyPath &&
+      envText === this.lastEnvText &&
+      installationMethod === this.lastInstallationMethod
+    ) {
+      return this.resolvedPath;
+    }
+
+    this.lastHostnamePath = hostnamePath;
+    this.lastLegacyPath = legacyPath;
+    this.lastEnvText = envText;
+    this.lastInstallationMethod = installationMethod;
+
+    this.resolvedPath = resolveCodexCliPath(hostnamePath, legacyPath, envText, {
+      installationMethod,
+    });
+    return this.resolvedPath;
+  }
+
+  resolve(
+    hostnamePaths: HostnameCliPaths | undefined,
+    legacyPath: string | undefined,
+    envText: string,
+    options: {
+      installationMethod?: CodexInstallationMethod;
+      hostPlatform?: NodeJS.Platform;
+    } = {},
+  ): string | null {
+    const hostnamePath = (hostnamePaths?.[this.cachedHostname] ?? '').trim();
+    const normalizedLegacyPath = (legacyPath ?? '').trim();
+    return resolveCodexCliPath(hostnamePath, normalizedLegacyPath, envText, options);
+  }
+
+  reset(): void {
+    this.resolvedPath = null;
+    this.lastHostnamePath = '';
+    this.lastLegacyPath = '';
+    this.lastEnvText = '';
+    this.lastInstallationMethod = '';
+  }
+}

package/src/providers/codex/runtime/CodexExecutionTargetResolver.ts

@@ -0,0 +1,104 @@
+import { execFileSync } from 'child_process';
+
+import { getCodexProviderSettings } from '../settings';
+import type {
+  CodexExecutionPlatformFamily,
+  CodexExecutionPlatformOs,
+  CodexExecutionTarget,
+} from './codexLaunchTypes';
+
+export interface ResolveCodexExecutionTargetOptions {
+  settings: Record<string, unknown>;
+  hostPlatform?: NodeJS.Platform;
+  hostVaultPath?: string | null;
+  resolveDefaultWslDistro?: () => string | undefined;
+}
+
+function resolveHostPlatformOs(hostPlatform: NodeJS.Platform): CodexExecutionPlatformOs {
+  if (hostPlatform === 'win32') {
+    return 'windows';
+  }
+
+  if (hostPlatform === 'darwin') {
+    return 'macos';
+  }
+
+  return 'linux';
+}
+
+function resolveHostPlatformFamily(hostPlatform: NodeJS.Platform): CodexExecutionPlatformFamily {
+  return hostPlatform === 'win32' ? 'windows' : 'unix';
+}
+
+export function inferWslDistroFromWindowsPath(hostPath: string | null | undefined): string | undefined {
+  if (!hostPath) {
+    return undefined;
+  }
+
+  const normalized = hostPath.replace(/\//g, '\\');
+  const match = normalized.match(/^\\\\wsl\$\\([^\\]+)(?:\\|$)/i);
+  return match?.[1] || undefined;
+}
+
+export function parseDefaultWslDistroListOutput(output: string): string | undefined {
+  for (const line of output.replace(/\uFEFF/g, '').split(/\r?\n/)) {
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith('*')) {
+      continue;
+    }
+
+    const candidate = trimmed.slice(1).trimStart().split(/\s{2,}/)[0]?.trim();
+    if (candidate) {
+      return candidate;
+    }
+  }
+
+  return undefined;
+}
+
+function resolveDefaultWslDistroName(): string | undefined {
+  try {
+    const output = execFileSync('wsl.exe', ['--list', '--verbose'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+    });
+    return parseDefaultWslDistroListOutput(output);
+  } catch {
+    return undefined;
+  }
+}
+
+export function resolveCodexExecutionTarget(
+  options: ResolveCodexExecutionTargetOptions,
+): CodexExecutionTarget {
+  const hostPlatform = options.hostPlatform ?? process.platform;
+  if (hostPlatform !== 'win32') {
+    return {
+      method: 'host-native',
+      platformFamily: resolveHostPlatformFamily(hostPlatform),
+      platformOs: resolveHostPlatformOs(hostPlatform),
+    };
+  }
+
+  const codexSettings = getCodexProviderSettings(options.settings);
+  if (codexSettings.installationMethod === 'wsl') {
+    const distroName = codexSettings.wslDistroOverride
+      || inferWslDistroFromWindowsPath(options.hostVaultPath)
+      || options.resolveDefaultWslDistro?.()
+      || resolveDefaultWslDistroName();
+
+    return {
+      method: 'wsl',
+      platformFamily: 'unix',
+      platformOs: 'linux',
+      distroName,
+    };
+  }
+
+  return {
+    method: 'native-windows',
+    platformFamily: 'windows',
+    platformOs: 'windows',
+  };
+}

package/src/providers/codex/runtime/CodexLaunchSpecBuilder.ts

@@ -0,0 +1,85 @@
+import {
+  inferWslDistroFromWindowsPath,
+  resolveCodexExecutionTarget,
+} from './CodexExecutionTargetResolver';
+import type { CodexLaunchSpec } from './codexLaunchTypes';
+import { createCodexPathMapper } from './CodexPathMapper';
+
+export interface BuildCodexLaunchSpecOptions {
+  settings: Record<string, unknown>;
+  resolvedCliCommand: string | null;
+  hostVaultPath: string | null;
+  env: Record<string, string>;
+  hostPlatform?: NodeJS.Platform;
+  resolveDefaultWslDistro?: () => string | undefined;
+}
+
+const CODEX_APP_SERVER_ARGS = Object.freeze(['app-server', '--listen', 'stdio://']);
+
+export function buildCodexLaunchSpec(
+  options: BuildCodexLaunchSpecOptions,
+): CodexLaunchSpec {
+  const target = resolveCodexExecutionTarget({
+    settings: options.settings,
+    hostPlatform: options.hostPlatform,
+    hostVaultPath: options.hostVaultPath,
+    resolveDefaultWslDistro: options.resolveDefaultWslDistro,
+  });
+  const pathMapper = createCodexPathMapper(target);
+  const spawnCwd = options.hostVaultPath ?? process.cwd();
+
+  const workspaceDistro = inferWslDistroFromWindowsPath(options.hostVaultPath);
+  if (
+    target.method === 'wsl'
+    && target.distroName
+    && workspaceDistro
+    && target.distroName.toLowerCase() !== workspaceDistro.toLowerCase()
+  ) {
+    throw new Error(
+      `WSL distro override "${target.distroName}" does not match workspace distro "${workspaceDistro}"`,
+    );
+  }
+
+  if (target.method === 'wsl' && !target.distroName) {
+    throw new Error(
+      'Unable to determine the WSL distro. Set WSL distro override or configure a default WSL distro.',
+    );
+  }
+
+  const targetCwd = pathMapper.toTargetPath(spawnCwd);
+
+  if (!targetCwd) {
+    throw new Error('WSL mode only supports Windows drive paths and \\\\wsl$ workspace paths');
+  }
+
+  const resolvedCliCommand = options.resolvedCliCommand?.trim() || 'codex';
+  if (target.method === 'wsl') {
+    const args = [
+      ...(target.distroName ? ['--distribution', target.distroName] : []),
+      '--cd',
+      targetCwd,
+      resolvedCliCommand,
+      ...CODEX_APP_SERVER_ARGS,
+    ];
+
+    return {
+      target,
+      command: 'wsl.exe',
+      args,
+      spawnCwd,
+      targetCwd,
+      env: options.env,
+      pathMapper,
+    };
+  }
+
+  return {
+    target,
+    command: resolvedCliCommand,
+    args: [...CODEX_APP_SERVER_ARGS],
+    spawnCwd,
+    targetCwd,
+    env: options.env,
+    pathMapper,
+  };
+}