@yhong91/cpac 0.1.25 → 0.1.27

package/dist/targets/opencode.js

@@ -0,0 +1,59 @@
+import { spawn } from "node:child_process";
+import { apiBase, catalogModelId, fetchCatalog, } from "../config.js";
+import { CPACError } from "../util.js";
+const OPENCODE_OUTPUT_BUDGET = 32_000;
+// Ephemeral takeover: inline a CPA provider via OPENCODE_CONFIG_CONTENT so no
+// opencode config file is touched; the session ends with zero residue.
+export async function runOpencode(config, args, executable = "opencode") {
+    const apiKey = process.env[config.api_key_env]?.trim();
+    if (!apiKey)
+        throw new CPACError(`environment variable ${config.api_key_env} is not set`);
+    const catalog = await fetchCatalog(config.cpa_url, apiKey);
+    let document;
+    try {
+        document = JSON.parse(new TextDecoder().decode(catalog.bytes));
+    }
+    catch {
+        throw new CPACError("invalid CPA catalog");
+    }
+    const models = {};
+    for (const row of document.models) {
+        const id = catalogModelId(row);
+        if (!id)
+            continue;
+        const window = typeof row.context_window === "number" && row.context_window > 0
+            ? Math.floor(row.context_window)
+            : 0;
+        models[id] =
+            window > 0
+                ? {
+                    limit: {
+                        context: window,
+                        output: Math.min(OPENCODE_OUTPUT_BUDGET, window),
+                    },
+                }
+                : {};
+    }
+    const content = JSON.stringify({
+        provider: {
+            cpac: {
+                npm: "@ai-sdk/openai-compatible",
+                options: { baseURL: apiBase(config.cpa_url), apiKey },
+                models,
+            },
+        },
+    });
+    const env = {
+        ...process.env,
+        OPENCODE_CONFIG_CONTENT: content,
+    };
+    return await new Promise((resolve, reject) => {
+        const child = spawn(executable, args, { env, stdio: "inherit" });
+        child.once("error", (error) => {
+            reject(new CPACError(error instanceof Error && "code" in error && error.code === "ENOENT"
+                ? `${executable} not found`
+                : `cannot start ${executable}: ${error.message}`));
+        });
+        child.once("close", (code) => resolve(code ?? 1));
+    });
+}

package/dist/targets/pi.js

@@ -0,0 +1,32 @@
+import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CPACError, atomicWrite, ensureCpacBackup, expandUserPath, } from "../util.js";
+export function piExtensionsDir() {
+    return join(expandUserPath(process.env.PI_CODING_AGENT_DIR?.trim() || join(homedir(), ".pi", "agent")), "extensions");
+}
+export function isPiExtensionInstalled() {
+    return existsSync(join(piExtensionsDir(), "cpac.ts"));
+}
+function piTemplatePath() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "pi-extension.template");
+}
+function piExtensionContent(cpaUrl) {
+    return readFileSync(piTemplatePath(), "utf8").replace("__CPA_URL__", cpaUrl);
+}
+export async function installPiExtension(config) {
+    const dir = piExtensionsDir();
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const target = join(dir, "cpac.ts");
+    ensureCpacBackup(target);
+    atomicWrite(target, Buffer.from(piExtensionContent(config.cpa_url)), 0o644);
+    console.log(`Installed Pi extension: ${target}`);
+}
+export async function uninstallPiExtension() {
+    const target = join(piExtensionsDir(), "cpac.ts");
+    if (!existsSync(target))
+        throw new CPACError("Pi extension is not installed");
+    unlinkSync(target);
+    console.log(`Removed Pi extension: ${target}`);
+}

package/dist/util.js

@@ -0,0 +1,200 @@
+import { chmodSync, closeSync, copyFileSync, existsSync, fsyncSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, parse } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { Writable } from "node:stream";
+let atomicSequence = 0;
+export class CPACError extends Error {
+}
+export function objectValue(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function ensureCpacBackup(target) {
+    if (!existsSync(target))
+        return;
+    const backup = `${target}.cpac-backup`;
+    if (existsSync(backup))
+        return;
+    copyFileSync(target, backup);
+}
+export function expandUserPath(value) {
+    if (value === "~")
+        return homedir();
+    if (value.startsWith("~/") || value.startsWith("~\\"))
+        return join(homedir(), value.slice(2));
+    return value;
+}
+export async function checkboxPicker(title, items, max) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new CPACError("model selection requires an interactive terminal");
+    }
+    const stdin = process.stdin;
+    const out = process.stderr;
+    const selected = new Set();
+    let cursor = 0;
+    const lines = items.length + 1;
+    const render = () => {
+        out.write(`${title} [space: toggle, up/down: move, enter: confirm, q: cancel, max ${max}]\n`);
+        items.forEach((item, index) => {
+            const box = selected.has(index) ? "[x]" : "[ ]";
+            out.write(`${index === cursor ? ">" : " "} ${box} ${item}\n`);
+        });
+    };
+    const redraw = () => {
+        out.write(`\x1b[${lines}F`);
+        for (let line = 0; line < lines; line += 1)
+            out.write("\x1b[2K\x1b[1E");
+        out.write(`\x1b[${lines}F`);
+        render();
+    };
+    return await new Promise((resolvePromise, rejectPromise) => {
+        const finish = (error) => {
+            stdin.removeListener("data", onData);
+            try {
+                stdin.setRawMode(false);
+            }
+            catch {
+                // Terminal already gone; nothing to restore.
+            }
+            stdin.pause();
+            out.write("\n");
+            if (error)
+                rejectPromise(error);
+            else
+                resolvePromise([...selected].map((index) => items[index]));
+        };
+        const onData = (chunk) => {
+            const key = chunk.toString("utf8");
+            if (key === "\x03" || key === "q" || key === "\x1b") {
+                finish(new CPACError("model selection cancelled"));
+                return;
+            }
+            if (key === "\r" || key === "\n") {
+                if (max === 1 && selected.size === 0) {
+                    selected.add(cursor);
+                }
+                finish();
+                return;
+            }
+            if (key === "\x1b[A")
+                cursor = (cursor + items.length - 1) % items.length;
+            else if (key === "\x1b[B")
+                cursor = (cursor + 1) % items.length;
+            else if (key === " ") {
+                if (max === 1) {
+                    selected.clear();
+                    selected.add(cursor);
+                    finish();
+                    return;
+                }
+                if (selected.has(cursor))
+                    selected.delete(cursor);
+                else if (selected.size < max)
+                    selected.add(cursor);
+            }
+            redraw();
+        };
+        stdin.setRawMode(true);
+        stdin.resume();
+        stdin.on("data", onData);
+        render();
+    });
+}
+export function tomlString(value) {
+    return JSON.stringify(value);
+}
+export function tomlStringArray(values) {
+    return `[ ${values.map(tomlString).join(", ")} ]`;
+}
+export function dominantEol(content) {
+    const crlf = (content.match(/\r\n/g) ?? []).length;
+    if (crlf === 0)
+        return "\n";
+    const bareLf = (content.match(/\n/g) ?? []).length - crlf;
+    return crlf >= bareLf ? "\r\n" : "\n";
+}
+export function atomicWrite(path, data, mode = 0o600) {
+    mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.cpac.${process.pid}.${Date.now()}.${++atomicSequence}.tmp`;
+    let descriptor;
+    try {
+        descriptor = openSync(temporary, "wx", 0o600);
+        writeFileSync(descriptor, data);
+        fsyncSync(descriptor);
+        closeSync(descriptor);
+        descriptor = undefined;
+        chmodSync(temporary, mode);
+        renameSync(temporary, path);
+    }
+    catch (error) {
+        if (descriptor !== undefined) {
+            try {
+                closeSync(descriptor);
+            }
+            catch (closeError) {
+                void closeError;
+            }
+        }
+        try {
+            unlinkSync(temporary);
+        }
+        catch (unlinkError) {
+            void unlinkError;
+        }
+        throw error;
+    }
+}
+export async function promptSecret(name) {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+        throw new CPACError(`environment variable ${name} is not set; run: export ${name}="..."`);
+    }
+    process.stderr.write(`Enter ${name}: `);
+    const silent = new Writable({
+        write(_chunk, _encoding, callback) {
+            callback();
+        },
+    });
+    const prompt = createInterface({
+        input: process.stdin,
+        output: silent,
+        terminal: true,
+    });
+    try {
+        const value = (await prompt.question("")).trim();
+        process.stderr.write("\n");
+        if (!value)
+            throw new CPACError(`${name} must not be empty`);
+        return value;
+    }
+    finally {
+        prompt.close();
+    }
+}
+export async function resolveApiKey(name) {
+    return process.env[name]?.trim() || (await promptSecret(name));
+}
+export function shellProfile() {
+    const shell = parse(process.env.SHELL || "").base;
+    if (shell === "zsh")
+        return join(homedir(), ".zshrc");
+    if (shell === "bash")
+        return join(homedir(), process.platform === "darwin" ? ".bash_profile" : ".bashrc");
+    if (["sh", "dash", "ksh"].includes(shell))
+        return join(homedir(), ".profile");
+    throw new CPACError(`unsupported shell ${shell || "unknown"}; run: export CPA_API_KEY="..."`);
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'"'"'`)}'`;
+}
+export function saveApiKeyExport(profile, name, apiKey) {
+    const start = `# >>> CPAC ${name} >>>`;
+    const end = `# <<< CPAC ${name} <<<`;
+    const block = `${start}\nexport ${name}=${shellQuote(apiKey)}\n${end}`;
+    let content = existsSync(profile) ? readFileSync(profile, "utf8") : "";
+    const managed = new RegExp(`${start.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}[\\s\\S]*?${end.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`);
+    content = managed.test(content)
+        ? content.replace(managed, block)
+        : `${content}${content && !content.endsWith("\n") ? "\n" : ""}${block}\n`;
+    const mode = existsSync(profile) ? statSync(profile).mode & 0o7777 : 0o600;
+    atomicWrite(profile, Buffer.from(content), mode);
+}

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@yhong91/cpac",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "Connect Codex and Claude Code to a remote CLIProxyAPI gateway",
   "type": "module",
   "bin": {
     "cpac": "dist/cpac.js"
   },
   "files": [
-    "dist/cpac.js",
-    "dist/pi-extension.template",
+    "dist",
     "cpac.example.json",
     "README.md"
   ],