@yhong91/cpac 0.1.24 → 0.1.26

package/dist/codex.js

@@ -0,0 +1,378 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, rmSync, statSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { PROVIDER, STATE_FILES, cleanupStateFiles, fetchCatalog, liftContextWindows, originalBytes, proxyFingerprint, readState, reorderCatalog, stateBytes, stateProxy, } from "./config.js";
+import { proxyIsHealthy, startProxyProcess, stopProxyProcess, } from "./proxy.js";
+import { CPACError, atomicWrite, dominantEol, tomlString } from "./util.js";
+const MODEL_PROVIDER_KEY = /^\s*(?:model_provider|"model_provider"|'model_provider')\s*=/;
+const MODEL_CATALOG_KEY = /^\s*(?:model_catalog_json|"model_catalog_json"|'model_catalog_json')\s*=/;
+const OPENAI_BASE_URL_KEY = /^\s*(?:openai_base_url|"openai_base_url"|'openai_base_url')\s*=/;
+const ROOT_KEY = new RegExp(`(?:${MODEL_PROVIDER_KEY.source}|${MODEL_CATALOG_KEY.source}|${OPENAI_BASE_URL_KEY.source})`);
+export const MANAGED_MARKER = "# CPAC managed; run CPAC 'restore' to restore the original file.";
+function providerPatterns(provider = PROVIDER) {
+    const escaped = provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const modelProviders = `(?:model_providers|"model_providers"|'model_providers')`;
+    const providerToken = `(?:${escaped}|"${escaped}"|'${escaped}')`;
+    return {
+        header: new RegExp(`^\\s*\\[\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*\\]\\s*(?:#.*)?$`),
+        arrayHeader: new RegExp(`^\\s*\\[\\[\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*\\]\\]\\s*(?:#.*)?$`),
+        parentHeader: new RegExp(`^\\s*\\[\\s*${modelProviders}\\s*\\]\\s*(?:#.*)?$`),
+        inlineKey: new RegExp(`^\\s*${providerToken}\\s*=`),
+        dottedKey: new RegExp(`^\\s*${modelProviders}\\s*\\.\\s*${providerToken}\\s*=`),
+    };
+}
+function providerHeader(provider = PROVIDER) {
+    return providerPatterns(provider).header;
+}
+export function hasProviderTable(content, provider = PROVIDER) {
+    const patterns = providerPatterns(provider);
+    let inRoot = true;
+    let inModelProviders = false;
+    for (const line of content.split(/\r?\n/)) {
+        if (patterns.header.test(line) || patterns.arrayHeader.test(line))
+            return true;
+        if (/^\s*\[/.test(line)) {
+            inRoot = false;
+            inModelProviders = patterns.parentHeader.test(line);
+            continue;
+        }
+        if ((inModelProviders && patterns.inlineKey.test(line)) ||
+            (inRoot && patterns.dottedKey.test(line)))
+            return true;
+    }
+    return false;
+}
+function stripManagedConfig(content) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(content);
+    }
+    catch {
+        throw new CPACError("Codex config must be UTF-8");
+    }
+    const eol = dominantEol(text);
+    const header = providerHeader();
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    let inRoot = true;
+    let inProvider = false;
+    let managedRootKeys = 0;
+    const kept = [];
+    for (const line of lines) {
+        if (inProvider && /^\s*\[/.test(line))
+            inProvider = false;
+        if (!inProvider && header.test(line)) {
+            inProvider = true;
+            continue;
+        }
+        if (inProvider)
+            continue;
+        if (/^\s*\[/.test(line))
+            inRoot = false;
+        if (inRoot && line === MANAGED_MARKER) {
+            managedRootKeys = 2;
+            continue;
+        }
+        if (inRoot && managedRootKeys > 0 && ROOT_KEY.test(line)) {
+            managedRootKeys -= 1;
+            continue;
+        }
+        kept.push(line);
+    }
+    const output = kept.join("\n");
+    return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
+}
+export function buildCodexConfig(original, proxyPort, catalogPath) {
+    let text;
+    try {
+        text = new TextDecoder("utf-8", { fatal: true }).decode(original);
+    }
+    catch {
+        throw new CPACError("Codex config must be UTF-8");
+    }
+    if (hasProviderTable(text)) {
+        throw new CPACError(`Codex config already contains [model_providers.${PROVIDER}]`);
+    }
+    const normalizedLines = text.replace(/\r\n/g, "\n").split("\n");
+    const firstTable = normalizedLines.findIndex((line) => /^\s*\[/.test(line));
+    const rootLines = normalizedLines.slice(0, firstTable === -1 ? undefined : firstTable);
+    const providerLine = rootLines.find((line) => MODEL_PROVIDER_KEY.test(line));
+    if (providerLine) {
+        const match = /=\s*["']([^"']+)["']/.exec(providerLine);
+        if (!match || match[1] !== "openai") {
+            throw new CPACError("Codex config selects an external model_provider; restore it to openai before injecting CPAC");
+        }
+    }
+    if (rootLines.some((line) => OPENAI_BASE_URL_KEY.test(line))) {
+        throw new CPACError("Codex config already contains openai_base_url; remove that user-owned override before injecting CPAC");
+    }
+    const eol = dominantEol(text);
+    const lines = text.replace(/\r\n/g, "\n").split("\n");
+    let inRoot = true;
+    const kept = lines.filter((line) => {
+        if (/^\s*\[/.test(line))
+            inRoot = false;
+        return !(inRoot && MODEL_CATALOG_KEY.test(line));
+    });
+    let body = kept.join("\n");
+    if (body && !body.endsWith("\n"))
+        body += "\n";
+    const root = [
+        MANAGED_MARKER,
+        `model_catalog_json = ${tomlString(catalogPath)}`,
+        `openai_base_url = ${tomlString(`http://127.0.0.1:${proxyPort}/v1`)}`,
+        "",
+    ].join("\n");
+    const output = root + body;
+    return Buffer.from(eol === "\n" ? output : output.replace(/\n/g, "\r\n"));
+}
+// Codex multi-agent v2 (features.multi_agent_v2). Accepts the same TOML
+// shapes codex-rs does: a [features.multi_agent_v2] table, an inline
+// `multi_agent_v2 = ...` under [features], or dotted root keys.
+const V2_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*\]\s*(?:#.*)?$/;
+const FEATURES_TABLE_HEADER = /^\s*\[\s*(?:features|"features"|'features')\s*\]\s*(?:#.*)?$/;
+const V2_KEY = /^\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')\s*=/;
+const V2_DOTTED_KEY = /^\s*(?:features|"features"|'features')\s*\.\s*(?:multi_agent_v2|"multi_agent_v2"|'multi_agent_v2')(?:\s*\.\s*(?:enabled|"enabled"|'enabled'))?\s*=/;
+function v2LineValue(line) {
+    const inline = line.match(/\{[^}]*\benabled\s*=\s*(true|false)/);
+    if (inline)
+        return inline[1] === "true";
+    const plain = line.match(/=\s*(true|false)(?![A-Za-z0-9_])/);
+    if (plain)
+        return plain[1] === "true";
+    return undefined;
+}
+export function multiAgentV2Enabled(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (V2_TABLE_HEADER.test(line)) {
+            table = "v2";
+            continue;
+        }
+        if (FEATURES_TABLE_HEADER.test(line)) {
+            table = "features";
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            table = "other";
+            continue;
+        }
+        if (table === "v2" && /^\s*(?:enabled|"enabled"|'enabled')\s*=/.test(line)) {
+            return v2LineValue(line) ?? false;
+        }
+        if (table === "features" && V2_KEY.test(line))
+            return v2LineValue(line) ?? false;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            return v2LineValue(line) ?? false;
+    }
+    return false;
+}
+function stripMultiAgentV2(content) {
+    const lines = content.replace(/\r\n/g, "\n").split("\n");
+    const kept = [];
+    let skipTable = false;
+    let table = "root";
+    for (const line of lines) {
+        if (/^\s*\[/.test(line)) {
+            skipTable = V2_TABLE_HEADER.test(line);
+            if (skipTable) {
+                table = "other";
+                continue;
+            }
+            table = FEATURES_TABLE_HEADER.test(line) ? "features" : "other";
+        }
+        if (skipTable)
+            continue;
+        if (table === "features" && V2_KEY.test(line))
+            continue;
+        if (table === "root" && V2_DOTTED_KEY.test(line))
+            continue;
+        kept.push(line);
+    }
+    return kept.join("\n");
+}
+function hasAgentsMaxThreads(content) {
+    let table = "root";
+    for (const line of content.replace(/\r\n/g, "\n").split("\n")) {
+        if (/^\s*\[/.test(line)) {
+            table = /^\s*\[\s*(?:agents|"agents"|'agents')\s*\]\s*(?:#.*)?$/.test(line)
+                ? "agents"
+                : "other";
+            continue;
+        }
+        if (table === "agents" && /^\s*max_threads\s*=/.test(line))
+            return true;
+        if (table === "root" &&
+            /^\s*(?:agents|"agents"|'agents')\s*\.\s*max_threads\s*=/.test(line))
+            return true;
+    }
+    return false;
+}
+export function withMultiAgentV2(content, enabled, eol) {
+    let body = stripMultiAgentV2(content);
+    if (body && !body.endsWith("\n"))
+        body += "\n";
+    const output = body + `\n[features.multi_agent_v2]\nenabled = ${enabled}\n`;
+    return eol === "\n" ? output : output.replace(/\n/g, "\r\n");
+}
+export async function inject(config, v2Off = false, maxContext = false) {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    if (!apiKey)
+        throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+    const state = readState(config.state_dir);
+    let existed;
+    let original;
+    let originalMode;
+    if (state) {
+        const backup = originalBytes(config.state_dir, state, config.codex_config);
+        try {
+            original = existsSync(config.codex_config)
+                ? stripManagedConfig(readFileSync(config.codex_config))
+                : backup;
+        }
+        catch (error) {
+            if (error instanceof CPACError)
+                throw error;
+            throw new CPACError(`cannot read Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        existed = state.config_existed;
+        originalMode = state.config_mode;
+    }
+    else {
+        existed = existsSync(config.codex_config);
+        try {
+            original = existed ? readFileSync(config.codex_config) : new Uint8Array();
+            originalMode = existed ? statSync(config.codex_config).mode & 0o7777 : 0o600;
+        }
+        catch (error) {
+            throw new CPACError(`cannot read Codex config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    if (config.spawn_models?.length)
+        catalog.bytes = reorderCatalog(catalog.bytes, config.spawn_models);
+    if (maxContext)
+        catalog.bytes = liftContextWindows(catalog.bytes);
+    const stateDirExisted = existsSync(config.state_dir);
+    if (!state &&
+        STATE_FILES.some((name) => existsSync(join(config.state_dir, name)))) {
+        throw new CPACError("state_dir contains CPAC files without a valid state; refusing to overwrite them");
+    }
+    const fingerprint = proxyFingerprint(config, apiKey);
+    const previousProxy = state ? stateProxy(state) : null;
+    let proxy;
+    let startedProxy = false;
+    if (previousProxy &&
+        state?.proxy_fingerprint === fingerprint &&
+        (config.codex_proxy_port === 0 ||
+            config.codex_proxy_port === previousProxy.port) &&
+        (await proxyIsHealthy(previousProxy))) {
+        proxy = previousProxy;
+    }
+    else {
+        if (previousProxy)
+            await stopProxyProcess(previousProxy);
+        try {
+            proxy = await startProxyProcess(config, apiKey);
+            startedProxy = true;
+        }
+        catch (error) {
+            throw new CPACError(`${error instanceof Error ? error.message : String(error)}; choose another codex_proxy_port if the port is occupied`);
+        }
+    }
+    const catalogPath = join(config.state_dir, "codex-models.json");
+    let injected;
+    try {
+        injected = buildCodexConfig(original, proxy.port, catalogPath);
+        const injectedText = new TextDecoder("utf-8").decode(injected);
+        injected = Buffer.from(withMultiAgentV2(injectedText, !v2Off, dominantEol(injectedText)));
+        if (!v2Off && hasAgentsMaxThreads(injectedText)) {
+            console.warn("warning: [agents] max_threads is set; codex refuses to start with multi_agent_v2 enabled, remove it");
+        }
+    }
+    catch (error) {
+        if (startedProxy)
+            await stopProxyProcess(proxy);
+        throw error;
+    }
+    mkdirSync(config.state_dir, { recursive: true, mode: 0o700 });
+    if (!stateDirExisted)
+        chmodSync(config.state_dir, 0o700);
+    if (state) {
+        try {
+            atomicWrite(catalogPath, catalog.bytes);
+            atomicWrite(config.codex_config, injected, originalMode);
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+        }
+        catch (error) {
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            throw error;
+        }
+    }
+    else {
+        let configWritten = false;
+        try {
+            if (existed)
+                atomicWrite(join(config.state_dir, "config.toml.backup"), original);
+            atomicWrite(catalogPath, catalog.bytes);
+            atomicWrite(config.codex_config, injected, originalMode);
+            configWritten = true;
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+        }
+        catch (error) {
+            if (configWritten) {
+                try {
+                    if (existed)
+                        atomicWrite(config.codex_config, original, originalMode);
+                    else
+                        rmSync(config.codex_config, { force: true });
+                }
+                catch (rollbackError) {
+                    throw new CPACError(`injection failed and config rollback failed; backup retained in ${config.state_dir}: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                }
+            }
+            let cleanupError;
+            try {
+                cleanupStateFiles(config.state_dir);
+            }
+            catch (caught) {
+                cleanupError = caught;
+            }
+            if (startedProxy)
+                await stopProxyProcess(proxy);
+            if (cleanupError) {
+                throw new CPACError(`injection failed and state cleanup failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+            throw error;
+        }
+    }
+    try {
+        rmSync(join(dirname(config.codex_config), "models_cache.json"), {
+            force: true,
+        });
+    }
+    catch {
+        console.warn("CPAC could not invalidate Codex models_cache.json; restart Codex App if its model list is stale.");
+    }
+    console.log(`Injected ${catalog.modelCount} CPA models into ${config.codex_config} via http://127.0.0.1:${proxy.port}/v1 (multi-agent v2: ${v2Off ? "off" : "on"})`);
+    console.log("Restart Codex App if its running app-server still shows the old model list.");
+}
+export async function restore(config) {
+    const state = readState(config.state_dir);
+    if (!state)
+        throw new CPACError("no active CPAC injection");
+    const original = originalBytes(config.state_dir, state, config.codex_config);
+    if (state.config_existed)
+        atomicWrite(config.codex_config, original, state.config_mode);
+    else
+        rmSync(config.codex_config, { force: true });
+    const proxy = stateProxy(state);
+    if (proxy)
+        await stopProxyProcess(proxy);
+    try {
+        cleanupStateFiles(config.state_dir);
+    }
+    catch (error) {
+        throw new CPACError(`config restored, but state cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    console.log(`Restored ${config.codex_config}`);
+}