mirror of
https://github.com/tiennm99/ccs.git
synced 2026-10-11 03:13:12 +00:00
472 lines
15 KiB
TypeScript
472 lines
15 KiB
TypeScript
import { ChildProcess, spawn } from 'child_process';
|
|
import * as fs from 'fs';
|
|
import type { ProfileType } from '../types/profile';
|
|
import { runCleanup } from '../errors';
|
|
import { expandPath } from '../utils/helpers';
|
|
import { wireChildProcessSignals } from '../utils/signal-forwarder';
|
|
import {
|
|
escapeShellArg,
|
|
getWindowsEscapedCommandShell,
|
|
stripBrowserEnv,
|
|
stripAnthropicEnv,
|
|
stripCodexSessionEnv,
|
|
} from '../utils/shell-executor';
|
|
import type {
|
|
TargetAdapter,
|
|
TargetBinaryInfo,
|
|
TargetCredentials,
|
|
TargetType,
|
|
} from './target-adapter';
|
|
import {
|
|
codexBinarySupportsConfigOverrides,
|
|
detectCodexCli,
|
|
getCodexBinaryInfo,
|
|
readCodexVersion,
|
|
} from './codex-detector';
|
|
import { createLogger } from '../services/logging';
|
|
import { getEffectiveApiKey } from '../cliproxy/auth/auth-token-manager';
|
|
import { resolveLifecyclePort } from '../cliproxy/config/port-manager';
|
|
import { getModelMaxLevel } from '../cliproxy/model-catalog';
|
|
import { parseCodexModelTuningAlias } from '../cliproxy/ai-providers/model-id-normalizer';
|
|
import {
|
|
CCSXP_CLIPROXY_SHORTCUT_ENV,
|
|
CODEX_CLIPROXY_PROVIDER_ENV_KEY,
|
|
ensureCodexCliproxyProviderConfig,
|
|
isCcsxpCliproxyShortcut,
|
|
} from './codex-cliproxy-provider-config';
|
|
|
|
const adapterLogger = createLogger('targets:codex');
|
|
|
|
const CODEX_RUNTIME_PROVIDER_ID = 'ccs_runtime';
|
|
const CODEX_RUNTIME_ENV_KEY = 'CCS_CODEX_API_KEY';
|
|
const CODEX_REASONING_LEVELS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh']);
|
|
const CODEX_INFO_FLAGS = new Set(['--help', '-h', '--version', '-v']);
|
|
const CODEX_FAST_SERVICE_TIER = 'priority';
|
|
|
|
function formatTomlString(value: string): string {
|
|
return JSON.stringify(value);
|
|
}
|
|
|
|
function buildConfigOverrideArgs(overrides: string[]): string[] {
|
|
return overrides.flatMap((override) => ['-c', override]);
|
|
}
|
|
|
|
function buildConfigOverrideSupportError(binaryInfo?: TargetBinaryInfo): Error {
|
|
const versionSummary = binaryInfo?.version ? ` (${binaryInfo.version})` : '';
|
|
return new Error(
|
|
`Codex CLI${versionSummary} does not advertise --config overrides. Upgrade Codex before using CCS-backed Codex profiles or runtime reasoning overrides.`
|
|
);
|
|
}
|
|
|
|
function hydrateCodexBinaryVersion(binaryInfo?: TargetBinaryInfo): TargetBinaryInfo | undefined {
|
|
if (!binaryInfo || binaryInfo.version || !binaryInfo.path) {
|
|
return binaryInfo;
|
|
}
|
|
|
|
return {
|
|
...binaryInfo,
|
|
version: readCodexVersion(binaryInfo.path),
|
|
};
|
|
}
|
|
|
|
function findDisallowedCodexManagedFlags(args: string[]): string[] {
|
|
const disallowed = new Set<string>();
|
|
|
|
for (const arg of args) {
|
|
if (arg === '-c' || arg === '--config' || arg.startsWith('--config=')) {
|
|
disallowed.add('--config/-c');
|
|
continue;
|
|
}
|
|
if (arg === '-p' || arg === '--profile' || arg.startsWith('--profile=')) {
|
|
disallowed.add('--profile/-p');
|
|
continue;
|
|
}
|
|
if (arg === '--oss') {
|
|
disallowed.add('--oss');
|
|
continue;
|
|
}
|
|
if (arg === '--local-provider' || arg.startsWith('--local-provider=')) {
|
|
disallowed.add('--local-provider');
|
|
}
|
|
}
|
|
|
|
return [...disallowed];
|
|
}
|
|
|
|
function normalizeCodexReasoningOverride(value: string | number | undefined): string | undefined {
|
|
if (value === undefined) {
|
|
return undefined;
|
|
}
|
|
if (typeof value === 'string' && CODEX_REASONING_LEVELS.has(value)) {
|
|
return value;
|
|
}
|
|
throw new Error(
|
|
'Codex target supports reasoning levels only: minimal, low, medium, high, xhigh.'
|
|
);
|
|
}
|
|
|
|
function normalizeCodexModelFlagValue(value: string): {
|
|
model: string;
|
|
effort?: string;
|
|
serviceTier?: string;
|
|
} | null {
|
|
const parsed = parseCodexModelTuningAlias(value);
|
|
if (!parsed || !parsed.baseModel) return null;
|
|
if (getModelMaxLevel('codex', parsed.baseModel) === undefined) return null;
|
|
return {
|
|
model: parsed.baseModel,
|
|
effort: parsed.effort ?? undefined,
|
|
serviceTier: parsed.serviceTier ? CODEX_FAST_SERVICE_TIER : undefined,
|
|
};
|
|
}
|
|
|
|
function normalizeCcsxpCodexModelFlagAliases(args: string[]): {
|
|
args: string[];
|
|
overrides: string[];
|
|
} {
|
|
const normalizedArgs = [...args];
|
|
let reasoningEffort: string | undefined;
|
|
let serviceTier: string | undefined;
|
|
|
|
const applyModelValue = (value: string): string => {
|
|
const normalized = normalizeCodexModelFlagValue(value);
|
|
if (!normalized) {
|
|
reasoningEffort = undefined;
|
|
serviceTier = undefined;
|
|
return value;
|
|
}
|
|
|
|
reasoningEffort = normalized.effort;
|
|
serviceTier = normalized.serviceTier;
|
|
return normalized.model;
|
|
};
|
|
|
|
for (let index = 0; index < normalizedArgs.length; index += 1) {
|
|
const arg = normalizedArgs[index];
|
|
if (arg === '-m' || arg === '--model') {
|
|
const nextValue = normalizedArgs[index + 1];
|
|
if (typeof nextValue === 'string') {
|
|
normalizedArgs[index + 1] = applyModelValue(nextValue);
|
|
index += 1;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
for (const prefix of ['--model=', '-m=']) {
|
|
if (arg.startsWith(prefix)) {
|
|
normalizedArgs[index] = `${prefix}${applyModelValue(arg.slice(prefix.length))}`;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
const overrides: string[] = [];
|
|
if (reasoningEffort) {
|
|
overrides.push(`model_reasoning_effort=${formatTomlString(reasoningEffort)}`);
|
|
}
|
|
if (serviceTier) {
|
|
overrides.push(`service_tier=${formatTomlString(serviceTier)}`);
|
|
}
|
|
|
|
return { args: normalizedArgs, overrides };
|
|
}
|
|
|
|
function isInformationalCodexInvocation(args: string[]): boolean {
|
|
if (args.length === 1) {
|
|
return CODEX_INFO_FLAGS.has(args[0] || '');
|
|
}
|
|
|
|
if (args.length === 2) {
|
|
return CODEX_INFO_FLAGS.has(args[1] || '');
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
function normalizeExplicitCodexHomeEnv(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
|
|
const rawCodexHome = env.CODEX_HOME;
|
|
if (rawCodexHome === undefined) {
|
|
return env;
|
|
}
|
|
|
|
const trimmedCodexHome = rawCodexHome.trim();
|
|
if (!trimmedCodexHome) {
|
|
const nextEnv = { ...env };
|
|
delete nextEnv.CODEX_HOME;
|
|
return nextEnv;
|
|
}
|
|
|
|
const normalizedCodexHome = expandPath(trimmedCodexHome);
|
|
if (normalizedCodexHome === rawCodexHome) {
|
|
return env;
|
|
}
|
|
|
|
return {
|
|
...env,
|
|
CODEX_HOME: normalizedCodexHome,
|
|
};
|
|
}
|
|
|
|
function prepareExplicitCodexHome(
|
|
env: NodeJS.ProcessEnv,
|
|
args: string[]
|
|
): { env: NodeJS.ProcessEnv; error?: string } {
|
|
const normalizedEnv = normalizeExplicitCodexHomeEnv(env);
|
|
const codexHome = normalizedEnv.CODEX_HOME;
|
|
if (!codexHome) {
|
|
return { env: normalizedEnv };
|
|
}
|
|
|
|
if (isInformationalCodexInvocation(args)) {
|
|
return { env: normalizedEnv };
|
|
}
|
|
|
|
try {
|
|
fs.mkdirSync(codexHome, { recursive: true });
|
|
} catch (err) {
|
|
const error = err as NodeJS.ErrnoException;
|
|
if (error.code !== 'EEXIST') {
|
|
return {
|
|
env: normalizedEnv,
|
|
error: `[X] Unable to initialize CODEX_HOME (${error.code || 'unknown'}): ${codexHome}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
try {
|
|
if (!fs.statSync(codexHome).isDirectory()) {
|
|
return {
|
|
env: normalizedEnv,
|
|
error: `[X] CODEX_HOME path is not a directory: ${codexHome}`,
|
|
};
|
|
}
|
|
return { env: normalizedEnv };
|
|
} catch (err) {
|
|
const error = err as NodeJS.ErrnoException;
|
|
return {
|
|
env: normalizedEnv,
|
|
error: `[X] Unable to access CODEX_HOME (${error.code || 'unknown'}): ${codexHome}`,
|
|
};
|
|
}
|
|
}
|
|
|
|
export class CodexAdapter implements TargetAdapter {
|
|
readonly type: TargetType = 'codex';
|
|
readonly displayName = 'Codex CLI';
|
|
private ccsxpCliproxyEnvKey = CODEX_CLIPROXY_PROVIDER_ENV_KEY;
|
|
|
|
detectBinary(): TargetBinaryInfo | null {
|
|
return getCodexBinaryInfo({ includeVersion: false, includeFeatures: false });
|
|
}
|
|
|
|
async prepareCredentials(_creds: TargetCredentials): Promise<void> {
|
|
if (!isCcsxpCliproxyShortcut()) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const providerRepair = await ensureCodexCliproxyProviderConfig(resolveLifecyclePort());
|
|
this.ccsxpCliproxyEnvKey = providerRepair.envKey;
|
|
} catch (error) {
|
|
throw new Error(
|
|
`ccsxp could not repair the native Codex cliproxy provider: ${(error as Error).message}`
|
|
);
|
|
}
|
|
}
|
|
|
|
buildArgs(
|
|
_profile: string,
|
|
userArgs: string[],
|
|
options?: {
|
|
creds?: TargetCredentials;
|
|
profileType?: ProfileType;
|
|
binaryInfo?: TargetBinaryInfo;
|
|
}
|
|
): string[] {
|
|
const profileType = options?.profileType || 'default';
|
|
const creds = options?.creds;
|
|
const reasoningOverride = normalizeCodexReasoningOverride(creds?.reasoningOverride);
|
|
const runtimeConfigOverrides = creds?.runtimeConfigOverrides ?? [];
|
|
|
|
if (profileType === 'default') {
|
|
const isCcsxpShortcut = isCcsxpCliproxyShortcut();
|
|
const modelFlagNormalization = isCcsxpShortcut
|
|
? normalizeCcsxpCodexModelFlagAliases(userArgs)
|
|
: { args: userArgs, overrides: [] };
|
|
const overrides = [...runtimeConfigOverrides, ...modelFlagNormalization.overrides];
|
|
if (reasoningOverride) {
|
|
overrides.push(`model_reasoning_effort=${formatTomlString(reasoningOverride)}`);
|
|
}
|
|
const needsConfigOverrideSupport = isCcsxpShortcut || overrides.length > 0;
|
|
if (needsConfigOverrideSupport && !codexBinarySupportsConfigOverrides(options?.binaryInfo)) {
|
|
throw buildConfigOverrideSupportError(hydrateCodexBinaryVersion(options?.binaryInfo));
|
|
}
|
|
if (overrides.length === 0) {
|
|
return modelFlagNormalization.args;
|
|
}
|
|
return [...buildConfigOverrideArgs(overrides), ...modelFlagNormalization.args];
|
|
}
|
|
|
|
if (!codexBinarySupportsConfigOverrides(options?.binaryInfo)) {
|
|
throw buildConfigOverrideSupportError(hydrateCodexBinaryVersion(options?.binaryInfo));
|
|
}
|
|
|
|
if (!creds?.baseUrl?.trim() || !creds.apiKey?.trim()) {
|
|
throw new Error(
|
|
'Codex target requires base URL and API key for CCS-backed profile launches.'
|
|
);
|
|
}
|
|
|
|
const disallowedFlags = findDisallowedCodexManagedFlags(userArgs);
|
|
if (disallowedFlags.length > 0) {
|
|
throw new Error(
|
|
`Codex target does not allow ${disallowedFlags.join(', ')} when CCS manages the runtime provider. Remove native Codex provider selection flags and retry.`
|
|
);
|
|
}
|
|
|
|
const overrides = [
|
|
`model_provider=${formatTomlString(CODEX_RUNTIME_PROVIDER_ID)}`,
|
|
`model_providers.${CODEX_RUNTIME_PROVIDER_ID}.name=${formatTomlString('CCS Runtime')}`,
|
|
`model_providers.${CODEX_RUNTIME_PROVIDER_ID}.base_url=${formatTomlString(creds.baseUrl)}`,
|
|
`model_providers.${CODEX_RUNTIME_PROVIDER_ID}.env_key=${formatTomlString(CODEX_RUNTIME_ENV_KEY)}`,
|
|
`model_providers.${CODEX_RUNTIME_PROVIDER_ID}.wire_api=${formatTomlString('responses')}`,
|
|
];
|
|
|
|
if (creds.model?.trim()) {
|
|
overrides.push(`model=${formatTomlString(creds.model)}`);
|
|
}
|
|
|
|
overrides.push(...runtimeConfigOverrides);
|
|
|
|
if (reasoningOverride) {
|
|
overrides.push(`model_reasoning_effort=${formatTomlString(reasoningOverride)}`);
|
|
}
|
|
|
|
return [...buildConfigOverrideArgs(overrides), ...userArgs];
|
|
}
|
|
|
|
buildEnv(creds: TargetCredentials, profileType: ProfileType): NodeJS.ProcessEnv {
|
|
const env: NodeJS.ProcessEnv = {
|
|
...stripBrowserEnv(stripCodexSessionEnv(stripAnthropicEnv(process.env))),
|
|
};
|
|
delete env[CCSXP_CLIPROXY_SHORTCUT_ENV];
|
|
delete env[CODEX_RUNTIME_ENV_KEY];
|
|
if (profileType === 'default' && isCcsxpCliproxyShortcut()) {
|
|
env[this.ccsxpCliproxyEnvKey || CODEX_CLIPROXY_PROVIDER_ENV_KEY] = getEffectiveApiKey();
|
|
}
|
|
if (profileType !== 'default') {
|
|
if (!creds.apiKey?.trim()) {
|
|
throw new Error('Codex target requires an API key for CCS-backed profile launches.');
|
|
}
|
|
env[CODEX_RUNTIME_ENV_KEY] = creds.apiKey;
|
|
}
|
|
return env;
|
|
}
|
|
|
|
exec(
|
|
args: string[],
|
|
env: NodeJS.ProcessEnv,
|
|
options?: { cwd?: string; binaryInfo?: TargetBinaryInfo }
|
|
): void {
|
|
const exitWithCleanup = (code: number): never => {
|
|
try {
|
|
runCleanup();
|
|
} catch {
|
|
// Cleanup is best-effort on launch errors.
|
|
}
|
|
process.exit(code);
|
|
};
|
|
|
|
const codexPath = options?.binaryInfo?.path || detectCodexCli();
|
|
if (!codexPath) {
|
|
console.error('[X] Codex CLI not found. Install a recent @openai/codex build first.');
|
|
return exitWithCleanup(1);
|
|
}
|
|
|
|
try {
|
|
const stat = fs.statSync(codexPath);
|
|
if (!stat.isFile()) {
|
|
console.error(`[X] Codex CLI path is not a file: ${codexPath}`);
|
|
return exitWithCleanup(1);
|
|
}
|
|
} catch (err) {
|
|
const error = err as NodeJS.ErrnoException;
|
|
console.error(
|
|
`[X] Codex CLI path is not accessible (${error.code || 'unknown'}): ${codexPath}`
|
|
);
|
|
return exitWithCleanup(1);
|
|
}
|
|
|
|
const codexHomePreparation = prepareExplicitCodexHome(env, args);
|
|
if (codexHomePreparation.error) {
|
|
console.error(codexHomePreparation.error);
|
|
return exitWithCleanup(1);
|
|
}
|
|
const launchEnv = codexHomePreparation.env;
|
|
|
|
const isWindows = process.platform === 'win32';
|
|
const isPowerShellScript = isWindows && /\.ps1$/i.test(codexPath);
|
|
const needsShell = isWindows && /\.(cmd|bat)$/i.test(codexPath);
|
|
|
|
const spawnStartedAt = Date.now();
|
|
adapterLogger.stage('dispatch', 'target.spawn', 'Spawning Codex CLI child process', {
|
|
target: 'codex',
|
|
codexPath,
|
|
argCount: args.length,
|
|
});
|
|
|
|
let child: ChildProcess;
|
|
if (isPowerShellScript) {
|
|
child = spawn(
|
|
'powershell.exe',
|
|
['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', codexPath, ...args],
|
|
{ stdio: 'inherit', windowsHide: true, env: launchEnv }
|
|
);
|
|
} else if (needsShell) {
|
|
const cmdString = [codexPath, ...args].map(escapeShellArg).join(' ');
|
|
child = spawn(cmdString, {
|
|
stdio: 'inherit',
|
|
windowsHide: true,
|
|
shell: getWindowsEscapedCommandShell(),
|
|
env: launchEnv,
|
|
});
|
|
} else {
|
|
child = spawn(codexPath, args, { stdio: 'inherit', windowsHide: true, env: launchEnv });
|
|
}
|
|
|
|
child.on('exit', (code, signal) => {
|
|
adapterLogger.stage(
|
|
'respond',
|
|
'target.exit',
|
|
'Codex CLI child process exited',
|
|
{ target: 'codex', exitCode: code, signal },
|
|
{ latencyMs: Date.now() - spawnStartedAt }
|
|
);
|
|
});
|
|
|
|
wireChildProcessSignals(child, (err: NodeJS.ErrnoException) => {
|
|
if (err.code === 'EACCES') {
|
|
console.error(`[X] Codex CLI is not executable: ${codexPath}`);
|
|
console.error(' Check file permissions and executable bit.');
|
|
} else if (err.code === 'ENOENT') {
|
|
if (isPowerShellScript) {
|
|
console.error('[X] PowerShell executable not found (required for .ps1 wrapper launch).');
|
|
} else if (needsShell) {
|
|
console.error('[X] Windows command shell not found for Codex wrapper launch.');
|
|
} else {
|
|
console.error(`[X] Codex CLI not found: ${codexPath}`);
|
|
}
|
|
} else {
|
|
console.error(`[X] Failed to start Codex CLI (${codexPath}): ${err.message}`);
|
|
}
|
|
return exitWithCleanup(1);
|
|
});
|
|
}
|
|
|
|
supportsProfileType(profileType: ProfileType): boolean {
|
|
// Bridge-backed settings profiles need additional compatibility context that the
|
|
// adapter contract does not receive, so keep the adapter-level claim conservative.
|
|
return profileType === 'default' || profileType === 'cliproxy';
|
|
}
|
|
}
|