theclawbay 0.2.13 → 0.3.1

package/README.md

@@ -60,20 +60,29 @@ After setup, restart terminal/VS Code once only if your own shell workflows depe
 - Full ChatGPT account model-picker behavior is tied to ChatGPT auth mode.
 - `theclawbay setup` keeps your existing Codex login state unchanged on purpose (so local history context is preserved and setup stays non-destructive).
 
-## Run Relay (Optional)
+## Link Only (Optional)
 
-Only needed as a fallback compatibility mode:
+If you only want to save backend/API-key state without applying local client config yet:
 
 ```sh
 theclawbay link --api-key <apiKey>
-theclawbay proxy
 ```
 
-By default this starts a local relay on `http://127.0.0.1:2455` and forwards to:
+## Logout
 
-- `https://theclawbay.com/api/codex-auth/v1/proxy/...`
+To remove local The Claw Bay API-key auth state from this machine:
 
-The command auto-detects whether `openclaw` and/or `opencode` are installed and configures them automatically.
+```sh
+theclawbay logout
+```
+
+## Release Notes (Maintainers)
+
+If a previous publish failed after version bump, publish the current local version without bumping again:
+
+```sh
+npm run release:publish
+```
 
 ## Notes
 

package/dist/commands/link.js

@@ -20,7 +20,7 @@ class LinkCommand extends base_command_1.BaseCommand {
             });
             this.log(`Linked. Managed config written to ${paths_1.managedConfigPath}`);
             this.log(`Backend: ${backendUrl}`);
-            this.log(`Run "theclawbay proxy" to start the local relay.`);
+            this.log(`Run "theclawbay setup" to configure Codex/OpenClaw/OpenCode on this machine.`);
         });
     }
 }

package/dist/commands/logout.d.ts

@@ -0,0 +1,5 @@
+import { BaseCommand } from "../lib/base-command";
+export default class LogoutCommand extends BaseCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/commands/logout.js

@@ -0,0 +1,241 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const base_command_1 = require("../lib/base-command");
+const paths_1 = require("../lib/config/paths");
+const DEFAULT_PROVIDER_ID = "theclawbay";
+const LEGACY_PROVIDER_ID = "codex-lb";
+const MANAGED_START = "# theclawbay-managed:start";
+const MANAGED_END = "# theclawbay-managed:end";
+const SHELL_START = "# theclawbay-shell-managed:start";
+const SHELL_END = "# theclawbay-shell-managed:end";
+const ENV_FILE = node_path_1.default.join(node_os_1.default.homedir(), ".config", "theclawbay", "env");
+const ENV_KEY_NAME = "CODEX_LB_API_KEY";
+function removeManagedBlock(source, start, end) {
+    const markerStart = source.indexOf(start);
+    if (markerStart < 0)
+        return source;
+    const markerEnd = source.indexOf(end, markerStart);
+    if (markerEnd < 0)
+        return `${source.slice(0, markerStart).trimEnd()}\n`;
+    return `${(source.slice(0, markerStart) + source.slice(markerEnd + end.length)).trimEnd()}\n`;
+}
+function removeProviderTable(source, providerId) {
+    const header = `[model_providers.${providerId}]`;
+    const lines = source.split(/\r?\n/);
+    const output = [];
+    for (let i = 0; i < lines.length; i++) {
+        if ((lines[i] ?? "").trim() !== header) {
+            output.push(lines[i] ?? "");
+            continue;
+        }
+        i++;
+        while (i < lines.length && !/^\s*\[[^\]]+\]\s*$/.test(lines[i] ?? ""))
+            i++;
+        i--;
+    }
+    return `${output.join("\n").trimEnd()}\n`;
+}
+function removeTopLevelProviderSelection(source) {
+    const lines = source.split(/\r?\n/);
+    const filtered = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*\[/.test(line)) {
+            filtered.push(...lines.slice(i));
+            break;
+        }
+        if (/^\s*#/.test(line) || !line.trim()) {
+            filtered.push(line);
+            continue;
+        }
+        const match = line.match(/^\s*model_provider\s*=\s*"([^"]+)"\s*$/);
+        if (!match) {
+            filtered.push(line);
+            continue;
+        }
+        if (match[1] === DEFAULT_PROVIDER_ID || match[1] === LEGACY_PROVIDER_ID)
+            continue;
+        filtered.push(line);
+    }
+    return `${filtered.join("\n").trimEnd()}\n`;
+}
+async function readFileIfExists(filePath) {
+    try {
+        return await promises_1.default.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+async function removeFileIfExists(filePath) {
+    try {
+        await promises_1.default.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+async function writeIfChanged(filePath, next, previous) {
+    if (next === previous)
+        return false;
+    await promises_1.default.writeFile(filePath, next, "utf8");
+    return true;
+}
+function objectRecordOr(value, fallback) {
+    if (typeof value === "object" && value !== null && !Array.isArray(value))
+        return { ...value };
+    return fallback;
+}
+async function cleanupCodexConfig() {
+    const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
+    const existing = await readFileIfExists(configPath);
+    if (existing === null)
+        return false;
+    let next = existing;
+    next = removeManagedBlock(next, MANAGED_START, MANAGED_END);
+    next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
+    next = removeProviderTable(next, LEGACY_PROVIDER_ID);
+    next = removeTopLevelProviderSelection(next);
+    return writeIfChanged(configPath, next, existing);
+}
+async function cleanupShellFiles() {
+    const updated = [];
+    const shellRcPaths = [".bashrc", ".zshrc", ".profile"].map((name) => node_path_1.default.join(node_os_1.default.homedir(), name));
+    for (const rcPath of shellRcPaths) {
+        const existing = await readFileIfExists(rcPath);
+        if (existing === null)
+            continue;
+        const next = removeManagedBlock(existing, SHELL_START, SHELL_END);
+        if (await writeIfChanged(rcPath, next, existing))
+            updated.push(rcPath);
+    }
+    return updated;
+}
+async function cleanupVsCodeHooks() {
+    const updated = [];
+    const homes = [".vscode-server", ".vscode-server-insiders"];
+    for (const home of homes) {
+        const setupPath = node_path_1.default.join(node_os_1.default.homedir(), home, "server-env-setup");
+        const existing = await readFileIfExists(setupPath);
+        if (existing === null)
+            continue;
+        const next = removeManagedBlock(existing, SHELL_START, SHELL_END);
+        if (await writeIfChanged(setupPath, next, existing))
+            updated.push(setupPath);
+    }
+    return updated;
+}
+async function cleanupOpenClawConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".openclaw", "openclaw.json");
+    const existingRaw = await readFileIfExists(configPath);
+    if (existingRaw === null || !existingRaw.trim())
+        return false;
+    let doc;
+    try {
+        doc = objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    const modelsRoot = objectRecordOr(doc.models, {});
+    const providersRoot = objectRecordOr(modelsRoot.providers, {});
+    for (const id of [DEFAULT_PROVIDER_ID, LEGACY_PROVIDER_ID]) {
+        if (id in providersRoot) {
+            delete providersRoot[id];
+            changed = true;
+        }
+    }
+    modelsRoot.providers = providersRoot;
+    doc.models = modelsRoot;
+    const agentsRoot = objectRecordOr(doc.agents, {});
+    const defaultsRoot = objectRecordOr(agentsRoot.defaults, {});
+    const modelRoot = objectRecordOr(defaultsRoot.model, {});
+    const primary = modelRoot.primary;
+    if (typeof primary === "string" &&
+        (primary.startsWith(`${DEFAULT_PROVIDER_ID}/`) || primary.startsWith(`${LEGACY_PROVIDER_ID}/`))) {
+        delete modelRoot.primary;
+        changed = true;
+    }
+    defaultsRoot.model = modelRoot;
+    agentsRoot.defaults = defaultsRoot;
+    doc.agents = agentsRoot;
+    if (!changed)
+        return false;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return true;
+}
+async function cleanupOpenCodeConfig() {
+    const configPath = node_path_1.default.join(node_os_1.default.homedir(), ".config", "opencode", "opencode.json");
+    const existingRaw = await readFileIfExists(configPath);
+    if (existingRaw === null || !existingRaw.trim())
+        return false;
+    let doc;
+    try {
+        doc = objectRecordOr(JSON.parse(existingRaw), {});
+    }
+    catch {
+        return false;
+    }
+    let changed = false;
+    const providerRoot = objectRecordOr(doc.provider, {});
+    for (const id of [DEFAULT_PROVIDER_ID, LEGACY_PROVIDER_ID]) {
+        if (id in providerRoot) {
+            delete providerRoot[id];
+            changed = true;
+        }
+    }
+    doc.provider = providerRoot;
+    const model = doc.model;
+    if (typeof model === "string" &&
+        (model.startsWith(`${DEFAULT_PROVIDER_ID}/`) || model.startsWith(`${LEGACY_PROVIDER_ID}/`))) {
+        delete doc.model;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await promises_1.default.writeFile(configPath, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return true;
+}
+class LogoutCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const deletedManagedPaths = (await Promise.all([
+                removeFileIfExists(paths_1.managedConfigPath),
+                removeFileIfExists(paths_1.legacyManagedConfigPathClayBay),
+                removeFileIfExists(paths_1.legacyManagedConfigPathCodexAuth),
+            ])).filter(Boolean).length;
+            const removedEnvFile = await removeFileIfExists(ENV_FILE);
+            const updatedShellFiles = await cleanupShellFiles();
+            const updatedVsCodeHooks = await cleanupVsCodeHooks();
+            const updatedCodexConfig = await cleanupCodexConfig();
+            const updatedOpenClawConfig = await cleanupOpenClawConfig();
+            const updatedOpenCodeConfig = await cleanupOpenCodeConfig();
+            delete process.env[ENV_KEY_NAME];
+            this.log("Logout complete");
+            this.log(`- Managed configs removed: ${deletedManagedPaths}`);
+            this.log(`- API key env file removed: ${removedEnvFile ? "yes" : "no"}`);
+            this.log(`- Shell profiles updated: ${updatedShellFiles.length ? updatedShellFiles.join(", ") : "none"}`);
+            this.log(`- VS Code env hooks updated: ${updatedVsCodeHooks.length ? updatedVsCodeHooks.join(", ") : "none"}`);
+            this.log(`- Codex config cleaned: ${updatedCodexConfig ? "yes" : "no"}`);
+            this.log(`- OpenClaw config cleaned: ${updatedOpenClawConfig ? "yes" : "no"}`);
+            this.log(`- OpenCode config cleaned: ${updatedOpenCodeConfig ? "yes" : "no"}`);
+            this.log("Note: restart terminals/VS Code windows to clear already-loaded shell environment.");
+        });
+    }
+}
+LogoutCommand.description = "Log out from local The Claw Bay API-key auth on this machine";
+exports.default = LogoutCommand;

package/dist/index.js

@@ -1,7 +1,40 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
 const core_1 = require("@oclif/core");
-void (0, core_1.run)()
-    .then(() => (0, core_1.flush)())
-    .catch(core_1.Errors.handle);
+const update_check_1 = require("./lib/update-check");
+function detectPackageVersion() {
+    try {
+        const packageJsonPath = node_path_1.default.join(__dirname, "..", "package.json");
+        const raw = (0, node_fs_1.readFileSync)(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.version === "string" ? parsed.version : "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
+async function maybePrintBareInvocationHint() {
+    if (process.argv.slice(2).length > 0)
+        return;
+    const packageName = "theclawbay";
+    const currentVersion = detectPackageVersion();
+    await (0, update_check_1.maybeNotifyUpdate)({
+        packageName,
+        currentVersion,
+        log: (message) => console.log(message),
+    }).catch(() => { });
+    console.log("Get your API key at: https://theclawbay.com/keys");
+    console.log("Then run: theclawbay setup --api-key <apiKey>");
+    console.log("");
+}
+async function main() {
+    await maybePrintBareInvocationHint();
+    await (0, core_1.run)().then(() => (0, core_1.flush)());
+}
+void main().catch(core_1.Errors.handle);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "theclawbay",
-  "version": "0.2.13",
-  "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access, with optional relay fallback.",
+  "version": "0.3.1",
+  "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access.",
   "license": "MIT",
   "bin": {
     "theclawbay": "dist/index.js"
@@ -14,6 +14,7 @@
     "release:patch": "./scripts/release-npm.sh patch",
     "release:minor": "./scripts/release-npm.sh minor",
     "release:major": "./scripts/release-npm.sh major",
+    "release:publish": "./scripts/release-npm.sh none",
     "release:dry-run": "./scripts/release-npm.sh patch --dry-run"
   },
   "engines": {
@@ -30,9 +31,7 @@
     "cli",
     "setup",
     "wan",
-    "proxy",
-    "api-key",
-    "relay"
+    "api-key"
   ],
   "preferGlobal": true,
   "dependencies": {

package/dist/commands/proxy.d.ts

@@ -1,13 +0,0 @@
-import { BaseCommand } from "../lib/base-command";
-export default class ProxyCommand extends BaseCommand {
-    static description: string;
-    static flags: {
-        host: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        port: import("@oclif/core/lib/interfaces").OptionFlag<number, import("@oclif/core/lib/interfaces").CustomOptions>;
-        backend: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        "api-key": import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
-        "base-path": import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        client: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-    };
-    run(): Promise<void>;
-}

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;