@yhong91/cpac 0.1.26 → 0.1.28

package/dist/config.js

@@ -31,6 +31,9 @@ const STATE_KEYS = new Set([
     "proxy_fingerprint",
     "proxy_pid",
     "proxy_port",
+    "injected_config_hash",
+    "injected_openai_base_url",
+    "injected_catalog_path",
 ]);
 export const STATE_FILES = [
     "state.json",
@@ -388,6 +391,21 @@ export function readState(stateDir) {
             !/^[a-f0-9]{64}$/.test(value.proxy_fingerprint))) {
         throw new CPACError("invalid loopback proxy fingerprint");
     }
+    if (value.injected_config_hash !== undefined &&
+        (typeof value.injected_config_hash !== "string" ||
+            !/^[a-f0-9]{64}$/.test(value.injected_config_hash))) {
+        throw new CPACError("invalid injected_config_hash in state");
+    }
+    if (value.injected_openai_base_url !== undefined &&
+        (typeof value.injected_openai_base_url !== "string" ||
+            !value.injected_openai_base_url.trim())) {
+        throw new CPACError("invalid injected_openai_base_url in state");
+    }
+    if (value.injected_catalog_path !== undefined &&
+        (typeof value.injected_catalog_path !== "string" ||
+            !value.injected_catalog_path.trim())) {
+        throw new CPACError("invalid injected_catalog_path in state");
+    }
     return value;
 }
 export function stateProxy(state) {
@@ -395,7 +413,21 @@ export function stateProxy(state) {
         ? { id: state.proxy_id, pid: state.proxy_pid, port: state.proxy_port }
         : null;
 }
-export function stateBytes(config, existed, mode, proxy, proxyFingerprint) {
+export function injectedOwnership(state) {
+    if (!state?.injected_config_hash ||
+        !state.injected_openai_base_url ||
+        !state.injected_catalog_path)
+        return undefined;
+    return {
+        hash: state.injected_config_hash,
+        openaiBaseUrl: state.injected_openai_base_url,
+        catalogPath: state.injected_catalog_path,
+    };
+}
+export function sha256Hex(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+export function stateBytes(config, existed, mode, proxy, proxyFingerprint, injected) {
     return Buffer.from(`${JSON.stringify({
         config_path: config.codex_config,
         config_existed: existed,
@@ -404,6 +436,13 @@ export function stateBytes(config, existed, mode, proxy, proxyFingerprint) {
         proxy_fingerprint: proxyFingerprint,
         proxy_pid: proxy.pid,
         proxy_port: proxy.port,
+        ...(injected
+            ? {
+                injected_config_hash: injected.hash,
+                injected_openai_base_url: injected.openaiBaseUrl,
+                injected_catalog_path: injected.catalogPath,
+            }
+            : {}),
     }, null, 2)}\n`);
 }
 export function originalBytes(stateDir, state, expectedPath) {

package/dist/cpac.js

@@ -3,18 +3,26 @@ import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
-import { CPAC_VERSION, isGrokConfigInstalled, isKimiConfigInstalled, isPiExtensionInstalled, runCodexConfig, runDetect, runInstall, runOpencode, runRestore, runSync, runTargetLauncher, runUpgrade, } from "./agents.js";
-import { runClaude, runClaudeConfig, runClaudeModels } from "./claude.js";
-import { inject, multiAgentV2Enabled } from "./codex.js";
+import { CPAC_VERSION, runCodexConfig, runDetect, runInstall, runRestore, runSync, runTargetLauncher, runUninstall, runUpgrade, } from "./agents.js";
+import { runClaude, runClaudeConfig, runClaudeModels, } from "./targets/claude.js";
+import { inject, multiAgentV2Enabled } from "./targets/codex.js";
+import { isGrokConfigInstalled } from "./targets/grok.js";
+import { isKimiConfigInstalled } from "./targets/kimi.js";
+import { runOpencode } from "./targets/opencode.js";
+import { isPiExtensionInstalled } from "./targets/pi.js";
 import { defaultConfigPath, loadConfig, originalBytes, pickSpawnModels, readState, saveSpawnModels, stateProxy, } from "./config.js";
 import { proxyIsHealthy, runProxy, runProxyChild } from "./proxy.js";
 import { CPACError, expandUserPath, promptSecret, saveApiKeyExport, shellProfile, } from "./util.js";
 export { PROVIDER, loadConfig, saveSpawnModels, liftContextWindows, reorderCatalog, readState, stateProxy, } from "./config.js";
 export { saveApiKeyExport } from "./util.js";
 export { stopProxyProcess } from "./proxy.js";
-export { buildCodexConfig, hasProviderTable, inject, multiAgentV2Enabled, restore, withMultiAgentV2, } from "./codex.js";
-export { claudeTierSlots, createClaudeProxy, runClaude } from "./claude.js";
-export { detectClientVersion, detectTargets, installGrokConfig, installKimiConfig, installPiExtension, isGrokConfigInstalled, isKimiConfigInstalled, isPiExtensionInstalled, runInstall, runOpencode, runRestore, runSync, runTargetLauncher, uninstallGrokConfig, uninstallKimiConfig, uninstallPiExtension, } from "./agents.js";
+export { buildCodexConfig, hasProviderTable, inject, multiAgentV2Enabled, restore, withMultiAgentV2, } from "./targets/codex.js";
+export { claudeTierSlots, createClaudeProxy, runClaude, } from "./targets/claude.js";
+export { detectClientVersion, detectTargets, runInstall, runRestore, runSync, runTargetLauncher, } from "./agents.js";
+export { installGrokConfig, isGrokConfigInstalled, uninstallGrokConfig, } from "./targets/grok.js";
+export { installKimiConfig, isKimiConfigInstalled, uninstallKimiConfig, } from "./targets/kimi.js";
+export { runOpencode } from "./targets/opencode.js";
+export { installPiExtension, isPiExtensionInstalled, uninstallPiExtension, } from "./targets/pi.js";
 export async function status(config) {
     const apiKey = process.env[config.api_key_env]?.trim();
     const keyConfigured = !!apiKey;
@@ -62,7 +70,11 @@ export async function status(config) {
     return 0;
 }
 async function guide(config) {
-    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac <agent> [args...] Launch an agent (codex, kimi, grok, pi, claude, opencode) through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok)\n  cpac restore           Restore the original Codex config\n  cpac detect            Show supported targets and install status\n  cpac install           Install CPA integration into detected targets\n  cpac sync              Refresh installed Codex/Pi/Kimi/Grok injections from CPA\n  cpac uninstall         Remove CPA integration from installed targets\n  cpac upgrade           Update cpac from npm and sync installed agents\n  cpac --help            Show command usage`);
+    console.log(`CPA Companion\n\nCPA: ${config.cpa_url}\nCPA_API_KEY: ${process.env[config.api_key_env]?.trim() ? "configured" : "not configured"}\n\nCommands:\n  cpac <agent> [args...] Launch an agent (codex, kimi, grok, pi, claude, opencode) through CPA\n  cpac inject            Inject CPA into Codex and start its loopback proxy\n  cpac proxy             Run the injected loopback proxy in the foreground\n  cpac status            Show agent support status (Codex, Claude, Pi, Kimi, Grok)\n  cpac restore --target <id> | --all  Detach injected agents
+  cpac detect            Show supported targets and install status
+  cpac install           Install CPA integration into detected targets
+  cpac sync              Refresh installed Codex/Pi/Kimi/Grok injections from CPA
+  cpac uninstall         Detach all agents, then remove the cpac package (confirms first)\n  cpac upgrade           Update cpac from npm and sync installed agents\n  cpac --help            Show command usage`);
     if (process.env[config.api_key_env]?.trim())
         return 0;
     const apiKey = await promptSecret(config.api_key_env);
@@ -78,20 +90,21 @@ function usage() {
     return [
         "Usage: cpac",
         "       cpac <codex|kimi|grok|pi|claude|opencode> [args...]",
-        "       cpac <codex|claude> setup",
+        "       cpac <codex|claude> --setup [args...]",
         "       cpac <codex|claude|kimi|grok|pi> clear",
         "       cpac inject [--v2_off] [--v2_models] [--max_context] [--config PATH]",
-        "       cpac restore [--target codex,pi,kimi,grok] [--all] [--dry-run] [--config PATH]",
+        "       cpac restore --target <id> | --all [--dry-run] [--config PATH]",
         "       cpac status [--config PATH]",
         "       cpac proxy [--config PATH]",
         "       cpac detect [--json] [--home PATH]",
         "       cpac install [--target codex,pi,kimi,grok] [--all] [--dry-run] [--force] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
         "       cpac sync [--target codex,pi,kimi,grok] [--all] [--dry-run] [--v2_off] [--v2_models] [--max_context] [--home PATH]",
+        "       cpac uninstall [--dry-run]",
         "       cpac upgrade [--check]",
-        "       cpac version",
+        "       cpac -v | --version",
         "",
         "launch an agent directly with `cpac <agent> [args...]` (all args forwarded).",
-        "configure an agent with `cpac <agent> setup` or restore with `cpac <agent> clear`.",
+        "configure then launch with `cpac <codex|claude> --setup`; restore with `cpac <agent> clear`.",
     ].join("\n");
 }
 function parseArgs(args) {
@@ -103,8 +116,7 @@ function parseArgs(args) {
         args[0] === "sync" ||
         args[0] === "uninstall" ||
         args[0] === "restore" ||
-        args[0] === "upgrade" ||
-        args[0] === "version") {
+        args[0] === "upgrade") {
         const parsed = {
             command: args[0],
             configPath: defaultConfigPath(),
@@ -169,10 +181,34 @@ function parseArgs(args) {
     if (["codex", "kimi", "grok", "pi", "claude", "opencode"].includes(args[0])) {
         const targetId = args[0];
         let configPath = defaultConfigPath();
-        if (args[1] === "clear" || args[1] === "--clear") {
-            for (let i = 2; i < args.length; i++) {
-                if (args[i] === "--config") {
-                    const val = args[++i];
+        const raw = args.slice(1);
+        let setup = false;
+        let clear = false;
+        const rest = [];
+        for (let i = 0; i < raw.length; i++) {
+            const arg = raw[i];
+            if (i === 0 && arg === "setup") {
+                setup = true;
+                continue;
+            }
+            if (i === 0 && arg === "clear") {
+                clear = true;
+                continue;
+            }
+            if (arg === "--setup") {
+                setup = true;
+                continue;
+            }
+            if (arg === "--clear") {
+                clear = true;
+                continue;
+            }
+            rest.push(arg);
+        }
+        if (clear) {
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i] === "--config") {
+                    const val = rest[++i];
                     if (val)
                         configPath = resolve(expandUserPath(val));
                 }
@@ -201,13 +237,17 @@ function parseArgs(args) {
                 maxContext: false,
             };
         }
-        if (args[1] === "setup" || args[1] === "--setup") {
-            for (let i = 2; i < args.length; i++) {
-                if (args[i] === "--config") {
-                    const val = args[++i];
-                    if (val)
-                        configPath = resolve(expandUserPath(val));
+        if (setup) {
+            const launchArgs = [];
+            for (let i = 0; i < rest.length; i++) {
+                if (rest[i] === "--config") {
+                    const val = rest[++i];
+                    if (!val)
+                        throw new CPACError("--config requires a path");
+                    configPath = resolve(expandUserPath(val));
+                    continue;
                 }
+                launchArgs.push(rest[i]);
             }
             if (targetId === "codex") {
                 return {
@@ -218,6 +258,8 @@ function parseArgs(args) {
                     maxContext: false,
                     reset: false,
                     interactive: true,
+                    launch: true,
+                    args: launchArgs,
                 };
             }
             if (targetId === "claude") {
@@ -228,11 +270,13 @@ function parseArgs(args) {
                     pick: [],
                     reset: false,
                     interactive: true,
+                    launch: true,
+                    args: launchArgs,
                 };
             }
             throw new CPACError(`${targetId} does not require setup (all CPA models are auto-synced). Run 'cpac ${targetId}' or 'cpac install --target ${targetId}'.`);
         }
-        const passArgs = args.slice(1);
+        const passArgs = rest;
         if (targetId === "codex") {
             return {
                 command: "codex",
@@ -372,6 +416,10 @@ export async function main(args = process.argv.slice(2)) {
                 return 1;
             return await runProxyChild(port);
         }
+        if (args[0] === "--version" || args[0] === "-v") {
+            console.log(CPAC_VERSION);
+            return 0;
+        }
         const parsed = parseArgs(args);
         if (!parsed)
             return 0;
@@ -413,34 +461,48 @@ export async function main(args = process.argv.slice(2)) {
                 maxContext: parsed.maxContext,
             });
         }
-        if (parsed.command === "uninstall" || parsed.command === "restore")
+        if (parsed.command === "restore")
             return await runRestore(config, parsed.targets, {
                 all: parsed.all,
                 dryRun: parsed.dryRun,
             });
+        if (parsed.command === "uninstall") {
+            if (parsed.targets.length || parsed.all) {
+                throw new CPACError("uninstall removes the cpac package; detach agents with: cpac restore --target <id> | --all");
+            }
+            return await runUninstall(config, { dryRun: parsed.dryRun });
+        }
         if (parsed.command === "upgrade")
             return await runUpgrade(config, parsed.check);
-        if (parsed.command === "version") {
-            console.log(CPAC_VERSION);
-            return 0;
-        }
         if (parsed.command === "claude")
             return await runClaude(config, parsed.args);
-        if (parsed.command === "claude-config")
-            return await runClaudeConfig(config, parsed.configPath, {
+        if (parsed.command === "claude-config") {
+            const code = await runClaudeConfig(config, parsed.configPath, {
                 models: parsed.models,
                 pick: parsed.pick,
                 reset: parsed.reset,
                 interactive: parsed.interactive,
             });
-        if (parsed.command === "codex-config")
-            return await runCodexConfig(config, parsed.configPath, {
+            if (code !== 0 || !parsed.launch)
+                return code;
+            if (!process.stdin.isTTY || !process.stderr.isTTY)
+                return code;
+            return await runClaude(loadConfig(parsed.configPath, true), parsed.args ?? []);
+        }
+        if (parsed.command === "codex-config") {
+            const code = await runCodexConfig(config, parsed.configPath, {
                 v2Off: parsed.v2Off,
                 v2Models: parsed.v2Models,
                 maxContext: parsed.maxContext,
                 reset: parsed.reset,
                 interactive: parsed.interactive,
             });
+            if (code !== 0 || !parsed.launch)
+                return code;
+            if (!process.stdin.isTTY || !process.stderr.isTTY)
+                return code;
+            return await runTargetLauncher(loadConfig(parsed.configPath, true), "codex", parsed.args ?? [], "codex", { skipSync: true });
+        }
         if (parsed.command === "opencode")
             return await runOpencode(config, parsed.args);
         if (parsed.command === "codex") {

package/dist/proxy.js

@@ -5,7 +5,7 @@ import { createServer, request as httpRequest, } from "node:http";
 import { request as httpsRequest } from "node:https";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { apiBase, originalBytes, proxyFingerprint, readState, stateBytes, stateProxy, } from "./config.js";
+import { apiBase, injectedOwnership, originalBytes, proxyFingerprint, readState, stateBytes, stateProxy, } from "./config.js";
 import { CPACError, atomicWrite, objectValue, resolveApiKey } from "./util.js";
 const HOP_BY_HOP_HEADERS = new Set([
     "connection",
@@ -322,7 +322,7 @@ export async function runProxy(config) {
     }
     const proxy = await createLoopbackProxy(config.cpa_url, apiKey, recorded.id, recorded.port);
     try {
-        atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, state.config_existed, state.config_mode, { id: recorded.id, pid: process.pid, port: proxy.port }, proxyFingerprint(config, apiKey)));
+        atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, state.config_existed, state.config_mode, { id: recorded.id, pid: process.pid, port: proxy.port }, proxyFingerprint(config, apiKey), injectedOwnership(state)));
     }
     catch (error) {
         proxy.server.closeAllConnections?.();

package/dist/{claude.js → targets/claude.js}

@@ -2,9 +2,9 @@ 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";
+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

package/dist/{codex.js → targets/codex.js}

@@ -1,13 +1,44 @@
 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";
+import { PROVIDER, STATE_FILES, cleanupStateFiles, fetchCatalog, injectedOwnership, liftContextWindows, originalBytes, proxyFingerprint, readState, reorderCatalog, sha256Hex, 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 tomlQuotedValue(line) {
+    const eq = line.indexOf("=");
+    if (eq === -1)
+        return undefined;
+    const rest = line.slice(eq + 1).trimStart();
+    if (rest.startsWith('"')) {
+        const match = /^(?:"(?:\\.|[^"\\])*")/.exec(rest);
+        if (!match)
+            return undefined;
+        try {
+            return JSON.parse(match[0]);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (rest.startsWith("'")) {
+        const end = rest.indexOf("'", 1);
+        return end === -1 ? undefined : rest.slice(1, end);
+    }
+    return undefined;
+}
+function ownedRootLine(line, owned) {
+    if (!owned)
+        return false;
+    const value = tomlQuotedValue(line);
+    if (value === undefined)
+        return false;
+    return ((MODEL_CATALOG_KEY.test(line) && value === owned.catalogPath) ||
+        (OPENAI_BASE_URL_KEY.test(line) && value === owned.openaiBaseUrl));
+}
 function providerPatterns(provider = PROVIDER) {
     const escaped = provider.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     const modelProviders = `(?:model_providers|"model_providers"|'model_providers')`;
@@ -41,7 +72,7 @@ export function hasProviderTable(content, provider = PROVIDER) {
     }
     return false;
 }
-function stripManagedConfig(content) {
+function stripManagedConfig(content, owned) {
     let text;
     try {
         text = new TextDecoder("utf-8", { fatal: true }).decode(content);
@@ -75,6 +106,8 @@ function stripManagedConfig(content) {
             managedRootKeys -= 1;
             continue;
         }
+        if (inRoot && ownedRootLine(line, owned))
+            continue;
         kept.push(line);
     }
     const output = kept.join("\n");
@@ -225,7 +258,7 @@ export async function inject(config, v2Off = false, maxContext = false) {
         const backup = originalBytes(config.state_dir, state, config.codex_config);
         try {
             original = existsSync(config.codex_config)
-                ? stripManagedConfig(readFileSync(config.codex_config))
+                ? stripManagedConfig(readFileSync(config.codex_config), injectedOwnership(state))
                 : backup;
         }
         catch (error) {
@@ -293,6 +326,11 @@ export async function inject(config, v2Off = false, maxContext = false) {
             await stopProxyProcess(proxy);
         throw error;
     }
+    const ownership = {
+        hash: state?.injected_config_hash ?? sha256Hex(injected),
+        openaiBaseUrl: `http://127.0.0.1:${proxy.port}/v1`,
+        catalogPath,
+    };
     mkdirSync(config.state_dir, { recursive: true, mode: 0o700 });
     if (!stateDirExisted)
         chmodSync(config.state_dir, 0o700);
@@ -300,7 +338,7 @@ export async function inject(config, v2Off = false, maxContext = false) {
         try {
             atomicWrite(catalogPath, catalog.bytes);
             atomicWrite(config.codex_config, injected, originalMode);
-            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint));
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint, ownership));
         }
         catch (error) {
             if (startedProxy)
@@ -316,7 +354,7 @@ export async function inject(config, v2Off = false, maxContext = false) {
             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));
+            atomicWrite(join(config.state_dir, "state.json"), stateBytes(config, existed, originalMode, proxy, fingerprint, ownership));
         }
         catch (error) {
             if (configWritten) {
@@ -361,10 +399,25 @@ export async function restore(config) {
     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 current = existsSync(config.codex_config)
+        ? readFileSync(config.codex_config)
+        : null;
+    const unchanged = !state.injected_config_hash ||
+        (current !== null && sha256Hex(current) === state.injected_config_hash);
+    if (!current || unchanged) {
+        if (state.config_existed)
+            atomicWrite(config.codex_config, original, state.config_mode);
+        else
+            rmSync(config.codex_config, { force: true });
+    }
+    else {
+        const stripped = stripManagedConfig(current, injectedOwnership(state));
+        const empty = new TextDecoder("utf-8").decode(stripped).trim() === "";
+        if (!state.config_existed && empty)
+            rmSync(config.codex_config, { force: true });
+        else
+            atomicWrite(config.codex_config, stripped, state.config_mode);
+    }
     const proxy = stateProxy(state);
     if (proxy)
         await stopProxyProcess(proxy);

package/dist/targets/grok.js

@@ -0,0 +1,109 @@
+import { existsSync, mkdirSync, readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { catalogModelId, catalogModelRows, fetchCatalog, readState, stateProxy, } from "../config.js";
+import { proxyIsHealthy } from "../proxy.js";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, resolveApiKey, tomlString, } from "../util.js";
+export function grokHome() {
+    const home = process.env.GROK_HOME?.trim() || join(homedir(), ".grok");
+    return expandUserPath(home);
+}
+export function grokConfigPath() {
+    return join(grokHome(), "config.toml");
+}
+const GROK_BLOCK_START = "# >>> CPAC Grok >>>";
+const GROK_BLOCK_END = "# <<< CPAC Grok <<<";
+const grokBlockRegex = new RegExp(`${GROK_BLOCK_START.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${GROK_BLOCK_END.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\n?`);
+export function isGrokConfigInstalled() {
+    try {
+        const content = readFileSync(grokConfigPath(), "utf8");
+        return (grokBlockRegex.test(content) ||
+            /^\s*\[model\.(?:"cpac\/|'cpac\/|cpac-)/m.test(content));
+    }
+    catch {
+        return false;
+    }
+}
+function isCpacGrokTableHeader(line) {
+    const header = line.match(/^\[([^\]]+)\]\s*$/);
+    if (!header)
+        return false;
+    const name = header[1];
+    return /^model\.(?:"cpac\/|'cpac\/|cpac-)/.test(name);
+}
+function stripOrphanCpacGrokTables(content) {
+    const eol = content.includes("\r\n") ? "\r\n" : "\n";
+    const out = [];
+    let skipping = false;
+    for (const line of content.split(/\r?\n/)) {
+        if (/^\[[^\]]+\]\s*$/.test(line))
+            skipping = isCpacGrokTableHeader(line);
+        if (!skipping)
+            out.push(line);
+    }
+    return out.join(eol).replace(/(?:\r?\n){3,}/g, `${eol}${eol}`);
+}
+function writeGrokBlock(path, block) {
+    let content = existsSync(path) ? readFileSync(path, "utf8") : "";
+    content = content.replace(grokBlockRegex, "");
+    const orphan = content.indexOf(GROK_BLOCK_START);
+    if (orphan !== -1)
+        content = content.slice(0, orphan);
+    content = stripOrphanCpacGrokTables(content);
+    if (block) {
+        content = `${content}${content && !content.endsWith("\n") ? "\n" : ""}${block}\n`;
+    }
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const mode = existsSync(path) ? statSync(path).mode & 0o7777 : 0o600;
+    atomicWrite(path, Buffer.from(content), mode);
+}
+export async function installGrokConfig(config) {
+    const apiKey = await resolveApiKey(config.api_key_env);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder("utf-8").decode(catalog.bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const rows = catalogModelRows(document) ?? [];
+    if (rows.length === 0)
+        throw new CPACError("CPA catalog contains no models");
+    const state = readState(config.state_dir);
+    const recorded = state ? stateProxy(state) : null;
+    const port = recorded?.port ?? config.codex_proxy_port;
+    if (!port) {
+        throw new CPACError("loopback proxy port unknown; run cpac inject first");
+    }
+    const lines = [GROK_BLOCK_START];
+    for (const row of rows) {
+        const slug = catalogModelId(row);
+        if (!slug)
+            continue;
+        const context = typeof row.context_window === "number" && row.context_window > 0
+            ? Math.floor(row.context_window)
+            : 200000;
+        const name = typeof row.display_name === "string" && row.display_name.trim()
+            ? `${row.display_name.trim()} (CPAC)`
+            : `CPAC ${slug}`;
+        lines.push(`[model."cpac/${slug}"]`, `model = ${tomlString(slug)}`, `base_url = "http://127.0.0.1:${port}/v1"`, 'api_backend = "responses"', '# Placeholder: the CPAC loopback proxy replaces it with the CPA key; run "cpac inject" to start the proxy.', 'api_key = "cpac-loopback"', `name = ${tomlString(name)}`, `context_window = ${context}`, "");
+    }
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    lines.push(GROK_BLOCK_END);
+    const target = grokConfigPath();
+    ensureCpacBackup(target);
+    writeGrokBlock(target, lines.join("\n"));
+    console.log(`Installed Grok Build provider config: ${target}`);
+    if (!recorded || !(await proxyIsHealthy(recorded))) {
+        console.log("Loopback proxy is not running; run: cpac inject");
+    }
+}
+export async function uninstallGrokConfig() {
+    const target = grokConfigPath();
+    if (!isGrokConfigInstalled())
+        throw new CPACError("Grok Build config is not installed");
+    writeGrokBlock(target, null);
+    console.log(`Removed Grok Build provider config: ${target}`);
+}