theclawbay 0.2.13 → 0.3.2

package/dist/commands/proxy.js

@@ -1,306 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_http_1 = __importDefault(require("node:http"));
-const node_stream_1 = require("node:stream");
-const node_child_process_1 = require("node:child_process");
-const promises_1 = require("node:readline/promises");
-const core_1 = require("@oclif/core");
-const base_command_1 = require("../lib/base-command");
-const config_1 = require("../lib/managed/config");
-function trimTrailingSlash(value) {
-    return value.replace(/\/+$/g, "");
-}
-function ensureLeadingSlash(value) {
-    return value.startsWith("/") ? value : `/${value}`;
-}
-function joinUrl(base, pathname) {
-    const url = new URL(base);
-    url.pathname = `${url.pathname.replace(/\/+$/g, "")}${pathname.startsWith("/") ? "" : "/"}${pathname}`;
-    return url.toString();
-}
-function normalizeUrl(raw, label) {
-    try {
-        const parsed = new URL(raw.trim());
-        return trimTrailingSlash(parsed.toString());
-    }
-    catch {
-        throw new Error(`invalid ${label} URL: ${raw}`);
-    }
-}
-function headersFromIncoming(source) {
-    const headers = new Headers();
-    for (const [key, value] of Object.entries(source)) {
-        if (!value)
-            continue;
-        const lower = key.toLowerCase();
-        if (lower === "host" || lower === "content-length" || lower === "authorization" || lower === "connection") {
-            continue;
-        }
-        if (Array.isArray(value)) {
-            headers.set(key, value.join(", "));
-        }
-        else {
-            headers.set(key, value);
-        }
-    }
-    return headers;
-}
-async function readIncomingBody(req) {
-    if (!req.method || req.method === "GET" || req.method === "HEAD")
-        return null;
-    const chunks = [];
-    for await (const chunk of req) {
-        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
-    }
-    if (!chunks.length)
-        return null;
-    return Buffer.concat(chunks);
-}
-function bufferToArrayBuffer(buffer) {
-    const bytes = new Uint8Array(buffer.length);
-    bytes.set(buffer);
-    return bytes.buffer;
-}
-function writeUpstreamHeaders(res, source) {
-    source.forEach((value, key) => {
-        const lower = key.toLowerCase();
-        if (lower === "connection" || lower === "transfer-encoding" || lower === "keep-alive")
-            return;
-        res.setHeader(key, value);
-    });
-}
-function hasCommand(name) {
-    const result = (0, node_child_process_1.spawnSync)("which", [name], { stdio: "ignore" });
-    return result.status === 0;
-}
-async function askClientChoice() {
-    const rl = (0, promises_1.createInterface)({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        const answer = (await rl.question("Which clients do you want to configure? [1] All detected [2] Codex [3] OpenClaw [4] OpenCode [5] Codex+OpenClaw: "))
-            .trim()
-            .toLowerCase();
-        if (answer === "2" || answer === "codex")
-            return "codex";
-        if (answer === "3" || answer === "openclaw")
-            return "openclaw";
-        if (answer === "4" || answer === "opencode")
-            return "opencode";
-        if (answer === "5" || answer === "both")
-            return "both";
-        return "all";
-    }
-    finally {
-        rl.close();
-    }
-}
-function clientTargetsForChoice(choice) {
-    if (choice === "codex")
-        return { codex: true, openclaw: false, opencode: false };
-    if (choice === "openclaw")
-        return { codex: false, openclaw: true, opencode: false };
-    if (choice === "opencode")
-        return { codex: false, openclaw: false, opencode: true };
-    if (choice === "both")
-        return { codex: true, openclaw: true, opencode: false };
-    return { codex: true, openclaw: true, opencode: true };
-}
-function detectedClientTargets() {
-    return {
-        codex: hasCommand("codex"),
-        openclaw: hasCommand("openclaw"),
-        opencode: hasCommand("opencode"),
-    };
-}
-function countEnabledTargets(targets) {
-    return Number(targets.codex) + Number(targets.openclaw) + Number(targets.opencode);
-}
-async function resolveClientChoice(mode) {
-    if (mode === "all") {
-        const detected = detectedClientTargets();
-        return countEnabledTargets(detected) > 0 ? detected : { codex: true, openclaw: false, opencode: false };
-    }
-    if (mode === "codex" || mode === "openclaw" || mode === "opencode" || mode === "both") {
-        return clientTargetsForChoice(mode);
-    }
-    const detected = detectedClientTargets();
-    const enabledCount = countEnabledTargets(detected);
-    if (enabledCount === 0)
-        return { codex: true, openclaw: false, opencode: false };
-    if (enabledCount === 1)
-        return detected;
-    if (process.stdin.isTTY && process.stdout.isTTY) {
-        const choice = await askClientChoice();
-        if (choice === "all")
-            return detected;
-        const requested = clientTargetsForChoice(choice);
-        return {
-            codex: requested.codex && detected.codex,
-            openclaw: requested.openclaw && detected.openclaw,
-            opencode: requested.opencode && detected.opencode,
-        };
-    }
-    return detected;
-}
-class ProxyCommand extends base_command_1.BaseCommand {
-    async run() {
-        await this.runSafe(async () => {
-            const { flags } = await this.parse(ProxyCommand);
-            const managed = await (0, config_1.readManagedConfig)();
-            if (!managed.apiKey?.trim()) {
-                throw new Error('API key auth is required. Re-link using "theclawbay link --api-key <key>".');
-            }
-            const backendUrl = normalizeUrl(flags.backend ?? managed.backendUrl, "--backend");
-            const apiKey = (flags["api-key"] ?? managed.apiKey ?? "").trim();
-            if (!apiKey) {
-                throw new Error("API key is required for WAN proxy mode.");
-            }
-            const basePath = ensureLeadingSlash(flags["base-path"].trim()).replace(/\/+$/g, "");
-            const proxyBase = `${trimTrailingSlash(backendUrl)}${basePath}`;
-            const targets = await resolveClientChoice(flags.client);
-            const server = node_http_1.default.createServer(async (req, res) => {
-                const method = req.method?.toUpperCase() ?? "GET";
-                const incomingUrl = new URL(req.url || "/", "http://local-proxy.invalid");
-                const routePath = incomingUrl.pathname.replace(/^\/+/, "");
-                const upstreamUrl = joinUrl(proxyBase, routePath);
-                const urlWithQuery = `${upstreamUrl}${incomingUrl.search || ""}`;
-                try {
-                    const headers = headersFromIncoming(req.headers);
-                    headers.set("Authorization", `Bearer ${apiKey}`);
-                    const bodyBuffer = await readIncomingBody(req);
-                    const body = bodyBuffer ? bufferToArrayBuffer(bodyBuffer) : undefined;
-                    const upstream = await fetch(urlWithQuery, {
-                        method,
-                        headers,
-                        body,
-                        redirect: "manual",
-                    });
-                    res.statusCode = upstream.status;
-                    res.statusMessage = upstream.statusText;
-                    writeUpstreamHeaders(res, upstream.headers);
-                    if (!upstream.body || method === "HEAD") {
-                        res.end();
-                        return;
-                    }
-                    const stream = node_stream_1.Readable.fromWeb(upstream.body);
-                    stream.on("error", () => {
-                        res.destroy();
-                    });
-                    stream.pipe(res);
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    res.statusCode = 502;
-                    res.setHeader("Content-Type", "application/json");
-                    res.end(JSON.stringify({ error: `proxy relay failed: ${message}` }));
-                }
-            });
-            await new Promise((resolve, reject) => {
-                server.once("error", reject);
-                server.listen(flags.port, flags.host, () => {
-                    server.off("error", reject);
-                    resolve();
-                });
-            });
-            const localBase = `http://${flags.host}:${flags.port}`;
-            this.log(`theclawbay WAN relay listening at ${localBase}`);
-            this.log(`Forwarding to ${proxyBase}`);
-            this.log("");
-            if (targets.codex) {
-                this.log("Codex CLI config snippet:");
-                this.log('model_provider = "theclawbay-wan"');
-                this.log("");
-                this.log("[model_providers.theclawbay-wan]");
-                this.log('name = "OpenAI"');
-                this.log(`base_url = "${localBase}/backend-api/codex"`);
-                this.log('wire_api = "responses"');
-                this.log(`chatgpt_base_url = "${localBase}"`);
-                this.log("requires_openai_auth = true");
-                this.log("");
-            }
-            if (targets.openclaw) {
-                const openClawProviderJson = JSON.stringify({
-                    baseUrl: `${localBase}/v1`,
-                    apiKey: "theclawbay-local",
-                    api: "openai-responses",
-                    models: [
-                        { id: "gpt-5.3-codex", name: "GPT-5.3 Codex" },
-                        { id: "gpt-5.3-codex-spark", name: "GPT-5.3 Codex Spark" },
-                        { id: "gpt-5.2-codex", name: "GPT-5.2 Codex" },
-                        { id: "gpt-5.1-codex", name: "GPT-5.1 Codex" },
-                    ],
-                });
-                this.log("OpenClaw setup:");
-                this.log("Run these once:");
-                this.log('openclaw config set agents.defaults.model.primary "theclawbay/gpt-5.3-codex"');
-                this.log('openclaw config set models.mode "merge"');
-                this.log(`openclaw config set models.providers.theclawbay '${openClawProviderJson}' --json`);
-                this.log("");
-            }
-            if (targets.opencode) {
-                this.log("OpenCode setup:");
-                this.log("Set in ~/.config/opencode/opencode.json:");
-                this.log(JSON.stringify({
-                    provider: {
-                        theclawbay: {
-                            npm: "@ai-sdk/openai-compatible",
-                            name: "theclawbay",
-                            options: {
-                                baseURL: `${localBase}/v1`,
-                                apiKey: "theclawbay-local",
-                            },
-                            models: {
-                                "gpt-5.3-codex": { name: "GPT-5.3 Codex" },
-                            },
-                        },
-                    },
-                    model: "theclawbay/gpt-5.3-codex",
-                }, null, 2));
-                this.log("");
-            }
-            await new Promise((resolve) => {
-                const stop = () => {
-                    server.close(() => resolve());
-                };
-                process.once("SIGINT", stop);
-                process.once("SIGTERM", stop);
-            });
-        });
-    }
-}
-ProxyCommand.description = "Run a local relay that forwards Codex/OpenAI requests to your The Claw Bay backend using API-key auth";
-ProxyCommand.flags = {
-    host: core_1.Flags.string({
-        default: "127.0.0.1",
-        description: "Local bind host",
-    }),
-    port: core_1.Flags.integer({
-        default: 2455,
-        description: "Local bind port",
-    }),
-    backend: core_1.Flags.string({
-        required: false,
-        description: "Override backend URL (defaults to linked managed backend)",
-    }),
-    "api-key": core_1.Flags.string({
-        required: false,
-        aliases: ["apiKey"],
-        description: "Override API key (defaults to linked managed API key)",
-    }),
-    "base-path": core_1.Flags.string({
-        default: "/api/codex-auth/v1/proxy",
-        description: "Server proxy base path",
-    }),
-    client: core_1.Flags.string({
-        required: false,
-        default: "auto",
-        options: ["auto", "codex", "openclaw", "opencode", "both", "all"],
-        description: "Client target to guide setup for",
-    }),
-};
-exports.default = ProxyCommand;