@yhong91/cpac 0.1.25 → 0.1.26

package/dist/claude.js

@@ -0,0 +1,373 @@
+import { spawn } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { createServer, request as httpRequest, } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { apiBase, catalogModelId, catalogModelRows, fetchCatalog, loadConfig, } from "./config.js";
+import { proxyHeaders, responseHeaders, upstreamUrl } from "./proxy.js";
+import { CPACError, atomicWrite, checkboxPicker, objectValue, resolveApiKey, } from "./util.js";
+const CLAUDE_ALIAS_PREFIX = "claude-cpac--";
+// Claude Code accepts CLAUDE_CODE_AUTO_COMPACT_WINDOW in 100K–1M (binary-verified).
+// A single global window cannot be per-model; 350K is opencodex's user-approved
+// default — high enough to mark mid-size models (372K/500K), low enough that
+// marking never outgrows a model's real window.
+const ONE_MILLION = 1_000_000;
+const COMPACT_WINDOW_DEFAULT = 350_000;
+function claudeCompactWindow(maxContext) {
+    return maxContext > 200_000 ? COMPACT_WINDOW_DEFAULT : undefined;
+}
+// [1m] marking predicate (opencodex rule): native claude models manage their own
+// marker; aliases mark when the real window is >= 1M, or when it clears 200K and
+// can host the compact window (marking below it would trip API limits mid-session).
+function shouldMarkOneMillion(id, window, compactWindow) {
+    if (id.startsWith("claude"))
+        return false;
+    if (window >= ONE_MILLION)
+        return true;
+    return (compactWindow !== undefined && window > 200_000 && window >= compactWindow);
+}
+// Auto tier defaults. Within the claude-family pool (whole catalog when no
+// claude model exists), opus matches its family name or stays unset; sonnet
+// and haiku match their family name first, then fall back through
+// gemini → grok → luna → first catalog row.
+function defaultClaudeSlots(models) {
+    if (!models.length)
+        return undefined;
+    const claudeRows = models.filter((model) => model.id.startsWith("claude"));
+    const pool = claudeRows.length ? claudeRows : models;
+    const family = (keyword) => pool.find((model) => model.id.includes(keyword));
+    const fallback = (keyword) => family(keyword) ??
+        models.find((model) => model.id.includes("gemini")) ??
+        models.find((model) => model.id.includes("grok")) ??
+        models.find((model) => model.id.includes("luna")) ??
+        models[0];
+    const slots = {
+        sonnet: fallback("sonnet").id,
+        haiku: fallback("haiku").id,
+    };
+    const opus = family("opus");
+    if (opus)
+        slots.opus = opus.id;
+    return slots;
+}
+// Resolve the tier-model env values: config overrides win over catalog
+// defaults; values are [1m]-marked per the predicate above (Claude Code
+// strips the marker before the request leaves).
+export function claudeTierSlots(override, models, compactWindow) {
+    const defaults = defaultClaudeSlots(models);
+    if (!defaults)
+        return undefined;
+    const windowById = new Map(models.map((model) => [model.id, model.window]));
+    const mark = (id) => !/\[1m\]$/i.test(id) &&
+        shouldMarkOneMillion(id, windowById.get(id) ?? 0, compactWindow)
+        ? `${id}[1m]`
+        : id;
+    const slots = {
+        sonnet: mark(override?.sonnet ?? defaults.sonnet),
+        haiku: mark(override?.haiku ?? defaults.haiku),
+    };
+    const opus = override?.opus ?? defaults.opus;
+    if (opus)
+        slots.opus = mark(opus);
+    return slots;
+}
+async function claudeModelList(cpaUrl, apiKey, response) {
+    let rows;
+    try {
+        const catalog = await fetch(`${apiBase(cpaUrl)}/models?client_version=1`, {
+            headers: { Authorization: `Bearer ${apiKey}`, Accept: "application/json" },
+            signal: AbortSignal.timeout(20_000),
+        });
+        if (catalog.ok)
+            rows = catalogModelRows(await catalog.json());
+    }
+    catch {
+        rows = undefined;
+    }
+    if (!rows) {
+        response.writeHead(502, { "content-type": "application/json" });
+        response.end(JSON.stringify({ error: "CPA catalog request failed" }));
+        return;
+    }
+    // Claude Code's /model picker only lists ids starting with claude/anthropic;
+    // expose every other catalog model as claude-cpac--<id>. Append the [1m]
+    // marker when the model can host the auto-compact window — that marker is
+    // the only signal that lifts context accounting above the 200K default
+    // (Claude Code strips it before the request reaches the proxy).
+    const rowsWithWindow = [];
+    let maxContext = 0;
+    for (const model of rows) {
+        const id = catalogModelId(model);
+        if (!id)
+            continue;
+        const window = typeof model.context_window === "number" && model.context_window > 0
+            ? Math.floor(model.context_window)
+            : 0;
+        if (window > maxContext)
+            maxContext = window;
+        rowsWithWindow.push({
+            id,
+            window,
+            alias: id.startsWith("claude") ? id : `${CLAUDE_ALIAS_PREFIX}${id}`,
+            display: typeof model.display_name === "string" && model.display_name.trim()
+                ? model.display_name
+                : id,
+        });
+    }
+    const compactWindow = claudeCompactWindow(maxContext);
+    const data = rowsWithWindow.map((row) => ({
+        type: "model",
+        id: shouldMarkOneMillion(row.id, row.window, compactWindow)
+            ? `${row.alias}[1m]`
+            : row.alias,
+        display_name: row.display,
+    }));
+    response.writeHead(200, { "content-type": "application/json" });
+    response.end(JSON.stringify({
+        data,
+        has_more: false,
+        first_id: data.length > 0 ? data[0].id : null,
+        last_id: data.length > 0 ? data[data.length - 1].id : null,
+    }));
+}
+export async function createClaudeProxy(cpaUrl, apiKey) {
+    const server = createServer((request, response) => {
+        const requestUrl = request.url ?? "/";
+        if (request.method === "GET" && requestUrl.startsWith("/v1/models")) {
+            void claudeModelList(cpaUrl, apiKey, response);
+            return;
+        }
+        let target;
+        try {
+            target = upstreamUrl(cpaUrl, requestUrl);
+        }
+        catch {
+            response.writeHead(400).end("invalid request URL");
+            return;
+        }
+        const chunks = [];
+        request.on("data", (chunk) => chunks.push(chunk));
+        request.once("error", () => response.destroy());
+        request.once("end", () => {
+            let body = Buffer.concat(chunks);
+            if (body.length > 0) {
+                try {
+                    const parsed = JSON.parse(body.toString("utf8"));
+                    if (objectValue(parsed) &&
+                        typeof parsed.model === "string" &&
+                        parsed.model.startsWith(CLAUDE_ALIAS_PREFIX)) {
+                        // Claude Code strips [1m] itself; keep the strip as a guard.
+                        parsed.model = parsed.model
+                            .slice(CLAUDE_ALIAS_PREFIX.length)
+                            .replace(/\[(1|2)m\]$/i, "");
+                        body = Buffer.from(JSON.stringify(parsed));
+                    }
+                }
+                catch {
+                    // not JSON; forward unchanged
+                }
+            }
+            const headers = proxyHeaders(request.headers, apiKey);
+            headers["content-length"] = String(body.length);
+            const send = target.protocol === "https:" ? httpsRequest : httpRequest;
+            const upstream = send(target, { method: request.method, headers }, (upstreamResponse) => {
+                response.writeHead(upstreamResponse.statusCode ?? 502, responseHeaders(upstreamResponse.headers));
+                upstreamResponse.pipe(response);
+            });
+            upstream.once("error", () => {
+                if (!response.headersSent) {
+                    response.writeHead(502, { "content-type": "application/json" });
+                }
+                if (!response.writableEnded)
+                    response.end(JSON.stringify({ error: "CPA upstream request failed" }));
+            });
+            request.once("aborted", () => upstream.destroy());
+            response.once("close", () => {
+                if (!response.writableEnded)
+                    upstream.destroy();
+            });
+            upstream.end(body);
+        });
+    });
+    server.on("clientError", (_error, socket) => socket.destroy());
+    await new Promise((resolveListen, rejectListen) => {
+        server.once("error", rejectListen);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", rejectListen);
+            resolveListen();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        server.close();
+        throw new CPACError("cannot determine Claude proxy port");
+    }
+    return { server, port: address.port };
+}
+export async function runClaudeConfig(config, configPath, options = {}) {
+    if (options.reset) {
+        let raw = {};
+        try {
+            const file = JSON.parse(readFileSync(configPath, "utf8"));
+            if (!objectValue(file))
+                throw new CPACError("config must be a JSON object");
+            raw = file;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT") {
+                if (error instanceof CPACError)
+                    throw error;
+                throw new CPACError(`cannot read config: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        delete raw.claude_models;
+        atomicWrite(configPath, Buffer.from(`${JSON.stringify(raw, null, 2)}\n`));
+        console.log("Claude Code tier models reset to CPA catalog auto-selection");
+        return 0;
+    }
+    if (options.interactive && (!process.stdin.isTTY || !process.stderr.isTTY)) {
+        console.log(config.claude_models
+            ? JSON.stringify(config.claude_models, null, 2)
+            : "claude_models not set; cpac claude auto-picks tier models from the CPA catalog");
+        return 0;
+    }
+    const models = { ...(options.models || {}) };
+    const shouldPick = options.interactive || (options.pick && options.pick.length > 0);
+    if (shouldPick) {
+        const apiKey = await resolveApiKey(config.api_key_env);
+        const catalog = await fetchCatalog(config.cpa_url, apiKey);
+        let document;
+        try {
+            document = JSON.parse(new TextDecoder().decode(catalog.bytes));
+        }
+        catch {
+            throw new CPACError("CPA catalog response is not valid JSON");
+        }
+        const slugs = (document.models ?? [])
+            .map((model) => (typeof model?.slug === "string" ? model.slug : ""))
+            .filter(Boolean);
+        const slotsToPick = options.pick && options.pick.length > 0
+            ? options.pick
+            : ["sonnet", "haiku", "opus"];
+        for (const slot of slotsToPick) {
+            const choices = slot === "sonnet" ? slugs : ["(auto-select from catalog)", ...slugs];
+            const [picked] = await checkboxPicker(`Select Claude Code ${slot.toUpperCase()} tier model:`, choices, 1);
+            if (picked && picked !== "(auto-select from catalog)") {
+                models[slot] = picked;
+            }
+        }
+    }
+    if (!Object.keys(models).length && !shouldPick) {
+        console.log(config.claude_models
+            ? JSON.stringify(config.claude_models, null, 2)
+            : "claude_models not set; cpac claude auto-picks tier models from the CPA catalog");
+        return 0;
+    }
+    let raw = {};
+    try {
+        const file = JSON.parse(readFileSync(configPath, "utf8"));
+        if (!objectValue(file))
+            throw new CPACError("config must be a JSON object");
+        raw = file;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT") {
+            if (error instanceof CPACError)
+                throw error;
+            throw new CPACError(`cannot read config: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    const existing = objectValue(raw.claude_models)
+        ? { ...raw.claude_models }
+        : {};
+    Object.assign(existing, models);
+    raw.claude_models = existing;
+    atomicWrite(configPath, Buffer.from(`${JSON.stringify(raw, null, 2)}\n`));
+    loadConfig(configPath);
+    console.log(`Claude Code tier models updated in ${configPath}:\n${JSON.stringify(raw.claude_models, null, 2)}`);
+    return 0;
+}
+export async function runClaudeModels(parsed) {
+    const config = loadConfig(parsed.configPath, true);
+    return await runClaudeConfig(config, parsed.configPath, {
+        models: parsed.models,
+        pick: parsed.pick,
+        reset: parsed.reset,
+        interactive: false,
+    });
+}
+export async function runClaude(config, args, executable = "claude") {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const proxy = await createClaudeProxy(config.cpa_url, apiKey);
+    const stopProxy = () => {
+        proxy.server.closeAllConnections?.();
+        proxy.server.close();
+    };
+    // Gateway discovery only carries {id, display_name}; Claude Code accounts
+    // claude-prefixed unknown models at 200K and ignores MAX_CONTEXT_TOKENS for
+    // them. The [1m] marker on the alias (added by the models listing) plus the
+    // auto-compact window is opencodex's working mechanism for bigger windows.
+    let maxContext = 0;
+    const catalogWindows = [];
+    try {
+        const catalog = await fetchCatalog(config.cpa_url, apiKey);
+        const rows = catalogModelRows(JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes))) ?? [];
+        for (const row of rows) {
+            const id = catalogModelId(row);
+            const window = typeof row.context_window === "number" && row.context_window > 0
+                ? Math.floor(row.context_window)
+                : 0;
+            if (id)
+                catalogWindows.push({ id, window });
+            if (window > maxContext)
+                maxContext = window;
+        }
+    }
+    catch {
+        // keep the default window when the catalog is unreachable
+    }
+    const compactWindow = claudeCompactWindow(maxContext);
+    const slots = claudeTierSlots(config.claude_models, catalogWindows, compactWindow);
+    const env = {
+        ...process.env,
+        ANTHROPIC_BASE_URL: `http://127.0.0.1:${proxy.port}`,
+        ANTHROPIC_AUTH_TOKEN: apiKey,
+        CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY: "1",
+        CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST: "1",
+    };
+    if (compactWindow !== undefined &&
+        !(Number(process.env.CLAUDE_CODE_AUTO_COMPACT_WINDOW) > 0)) {
+        env.CLAUDE_CODE_AUTO_COMPACT_WINDOW = String(compactWindow);
+    }
+    const setSlot = (name, value) => {
+        if (process.env[name] === undefined)
+            env[name] = value;
+    };
+    if (slots) {
+        // Route haiku/subagent tier traffic at catalog models instead of the
+        // stock claude-haiku-* ids the gateway does not carry. The opus slot
+        // stays unset when the catalog has no opus-family model.
+        if (slots.opus)
+            setSlot("ANTHROPIC_DEFAULT_OPUS_MODEL", slots.opus);
+        setSlot("ANTHROPIC_DEFAULT_SONNET_MODEL", slots.sonnet);
+        setSlot("ANTHROPIC_DEFAULT_HAIKU_MODEL", slots.haiku);
+        setSlot("ANTHROPIC_SMALL_FAST_MODEL", slots.haiku);
+    }
+    delete env.ANTHROPIC_API_KEY;
+    delete env.CLAUDE_CODE_USE_ANTHROPIC_AWS;
+    delete env.CLAUDE_CODE_USE_BEDROCK;
+    delete env.CLAUDE_CODE_USE_FOUNDRY;
+    delete env.CLAUDE_CODE_USE_VERTEX;
+    return await new Promise((resolve, reject) => {
+        const child = spawn(executable, args, { env, stdio: "inherit" });
+        child.once("error", (error) => {
+            stopProxy();
+            reject(new CPACError(error instanceof Error && "code" in error && error.code === "ENOENT"
+                ? `${executable} not found`
+                : `cannot start ${executable}: ${error.message}`));
+        });
+        child.once("close", (code) => {
+            stopProxy();
+            resolve(code ?? 1);
+        });
+    });
+}