theclawbay 0.2.1 → 0.2.4

package/README.md

@@ -2,11 +2,6 @@
 
 `theclawbay` is a customer CLI for The Claw Bay.
 
-It now does one job:
-
-- link your purchased API key
-- run a local relay that forwards Codex/OpenAI requests to your The Claw Bay backend
-
 This package no longer runs local account login automation or local account switching flows.
 
 > Not affiliated with OpenAI or Codex. Not an official tool.
@@ -14,7 +9,7 @@ This package no longer runs local account login automation or local account swit
 ## Requirements
 
 - Node.js 18+
-- Codex CLI installed (`@openai/codex`)
+- Codex CLI (`@openai/codex`) and/or OpenClaw CLI
 
 ## Install
 
@@ -22,25 +17,55 @@ This package no longer runs local account login automation or local account swit
 npm i -g theclawbay
 ```
 
-## Link
+If you use `nvm`, keep a single global prefix to avoid duplicate binaries:
+
+```sh
+npm config delete prefix
+```
+
+## One-Time Setup (Recommended)
 
 Use your purchased API key from your dashboard:
 
 ```sh
-theclawbay link --api-key <apiKey>
+theclawbay setup --api-key <apiKey>
+```
+
+This auto-detects installed clients and writes direct WAN API-key config so users can run directly.
+By default, Codex setup preserves local conversation history (no ChatGPT history sync mode).
+
+Explicit client targeting:
+
+```sh
+theclawbay setup --api-key <apiKey> --client codex
+theclawbay setup --api-key <apiKey> --client openclaw
+theclawbay setup --api-key <apiKey> --client both
 ```
 
-This defaults to `https://theclawbay.com`.
+If needed, skip the automatic Codex login step:
+
+```sh
+theclawbay setup --api-key <apiKey> --skip-login
+```
+
+If you explicitly want the prior ChatGPT-linked history mode:
+
+```sh
+theclawbay setup --api-key <apiKey> --openai-sync
+```
 
 If you operate a custom backend, pass it explicitly:
 
 ```sh
-theclawbay link --api-key <apiKey> --backend https://your-domain.com
+theclawbay setup --api-key <apiKey> --backend https://your-domain.com
 ```
 
-## Run Relay
+## Run Relay (Optional)
+
+Only needed as a fallback compatibility mode:
 
 ```sh
+theclawbay link --api-key <apiKey>
 theclawbay proxy
 ```
 
@@ -51,17 +76,6 @@ By default this starts a local relay on `http://127.0.0.1:2455` and forwards to:
 The command now auto-detects whether `codex`, `openclaw`, or both are installed and prints setup steps for the detected client(s).
 If both are installed and you're in an interactive terminal, it asks which one you want to configure.
 
-## Common Flags
-
-`theclawbay proxy` supports:
-
-- `--host` local bind host (default `127.0.0.1`)
-- `--port` local bind port (default `2455`)
-- `--backend` override backend URL from linked config
-- `--api-key` override API key from linked config
-- `--base-path` override server proxy path (default `/api/codex-auth/v1/proxy`)
-- `--client` setup target: `auto` | `codex` | `openclaw` | `both` (default `auto`)
-
 ## Notes
 
 - End users only need API keys. They do not need upstream account credentials.

package/dist/commands/setup.d.ts

@@ -0,0 +1,14 @@
+import { BaseCommand } from "../lib/base-command";
+export default class SetupCommand extends BaseCommand {
+    static description: string;
+    static flags: {
+        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>;
+        provider: 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>;
+        "openclaw-model": import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+        "skip-login": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        "openai-sync": import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/setup.js

@@ -0,0 +1,308 @@
+"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_path_1 = __importDefault(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const promises_2 = require("node:readline/promises");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../lib/base-command");
+const paths_1 = require("../lib/config/paths");
+const api_key_1 = require("../lib/managed/api-key");
+const config_1 = require("../lib/managed/config");
+const errors_1 = require("../lib/managed/errors");
+const DEFAULT_BACKEND_URL = "https://theclawbay.com";
+const DEFAULT_PROVIDER_ID = "theclawbay-wan";
+const MANAGED_START = "# theclawbay-managed:start";
+const MANAGED_END = "# theclawbay-managed:end";
+const DEFAULT_OPENCLAW_MODEL = "gpt-5.3-codex";
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/g, "");
+}
+function normalizeUrl(raw, label) {
+    try {
+        const parsed = new URL(raw.trim());
+        return trimTrailingSlash(parsed.toString());
+    }
+    catch {
+        throw new Error(`invalid ${label} URL: ${raw}`);
+    }
+}
+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_2.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await rl.question("Which client do you want to configure? [1] Codex [2] OpenClaw [3] Both: "))
+            .trim()
+            .toLowerCase();
+        if (answer === "2" || answer === "openclaw")
+            return "openclaw";
+        if (answer === "3" || answer === "both")
+            return "both";
+        return "codex";
+    }
+    finally {
+        rl.close();
+    }
+}
+async function resolveClientChoice(mode) {
+    if (mode === "codex" || mode === "openclaw" || mode === "both") {
+        return mode;
+    }
+    const codexInstalled = hasCommand("codex");
+    const openclawInstalled = hasCommand("openclaw");
+    if (codexInstalled && !openclawInstalled)
+        return "codex";
+    if (!codexInstalled && openclawInstalled)
+        return "openclaw";
+    if (codexInstalled && openclawInstalled) {
+        if (process.stdin.isTTY && process.stdout.isTTY) {
+            return askClientChoice();
+        }
+        return "both";
+    }
+    return "codex";
+}
+function removeManagedBlock(source) {
+    const start = source.indexOf(MANAGED_START);
+    if (start < 0)
+        return source;
+    const end = source.indexOf(MANAGED_END, start);
+    if (end < 0)
+        return source.slice(0, start).trimEnd() + "\n";
+    return (source.slice(0, start) + source.slice(end + MANAGED_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 upsertFirstKeyLine(source, key, tomlValue) {
+    const lines = source.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i] ?? "";
+        if (/^\s*#/.test(line))
+            continue;
+        if (/^\s*\[/.test(line))
+            break;
+        if (new RegExp(`^\\s*${key}\\s*=`).test(line)) {
+            lines[i] = `${key} = ${tomlValue}`;
+            return `${lines.join("\n").trimEnd()}\n`;
+        }
+    }
+    return `${`${key} = ${tomlValue}\n${source}`.trimEnd()}\n`;
+}
+async function writeCodexConfig(params) {
+    const configPath = node_path_1.default.join(paths_1.codexDir, "config.toml");
+    await promises_1.default.mkdir(paths_1.codexDir, { recursive: true });
+    let existing = "";
+    try {
+        existing = await promises_1.default.readFile(configPath, "utf8");
+    }
+    catch (error) {
+        const err = error;
+        if (err.code !== "ENOENT")
+            throw error;
+    }
+    const proxyRoot = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy`;
+    let next = existing;
+    next = removeManagedBlock(next);
+    next = removeProviderTable(next, params.providerId);
+    next = upsertFirstKeyLine(next, "model_provider", `"${params.providerId}"`);
+    const managedBlock = [
+        MANAGED_START,
+        `[model_providers.${params.providerId}]`,
+        'name = "OpenAI"',
+        `base_url = "${proxyRoot}/backend-api/codex"`,
+        'wire_api = "responses"',
+        ...(params.openaiSync
+            ? [`chatgpt_base_url = "${proxyRoot}"`, "requires_openai_auth = true"]
+            : []),
+        MANAGED_END,
+        "",
+    ].join("\n");
+    if (next.trim().length) {
+        next = `${next.trimEnd()}\n\n`;
+    }
+    next += managedBlock;
+    await promises_1.default.writeFile(configPath, next, "utf8");
+    return configPath;
+}
+function codexLoginWithApiKey(apiKey) {
+    const run = (0, node_child_process_1.spawnSync)("codex", ["login", "--with-api-key"], {
+        input: `${apiKey}\n`,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (run.status === 0)
+        return;
+    const stderr = (run.stderr ?? "").trim();
+    const stdout = (run.stdout ?? "").trim();
+    const details = stderr || stdout || "codex login returned a non-zero exit status";
+    throw new Error(`failed to store API key in Codex CLI: ${details}`);
+}
+function runOpenClawConfigCommand(args) {
+    const run = (0, node_child_process_1.spawnSync)("openclaw", args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (run.status === 0)
+        return;
+    const stderr = (run.stderr ?? "").trim();
+    const stdout = (run.stdout ?? "").trim();
+    const details = stderr || stdout || "openclaw command returned a non-zero exit status";
+    throw new Error(`failed to update OpenClaw config: ${details}`);
+}
+function setupOpenClaw(params) {
+    const base = trimTrailingSlash(params.backendUrl);
+    const model = params.model.trim() || DEFAULT_OPENCLAW_MODEL;
+    const provider = {
+        baseUrl: `${base}/api/codex-auth/v1/proxy/v1`,
+        apiKey: params.apiKey,
+        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" },
+        ],
+    };
+    runOpenClawConfigCommand(["config", "set", "agents.defaults.model.primary", `openai/${model}`]);
+    runOpenClawConfigCommand(["config", "set", "models.mode", "merge"]);
+    runOpenClawConfigCommand([
+        "config",
+        "set",
+        "models.providers.openai",
+        JSON.stringify(provider),
+        "--json",
+    ]);
+}
+class SetupCommand extends base_command_1.BaseCommand {
+    async run() {
+        await this.runSafe(async () => {
+            const { flags } = await this.parse(SetupCommand);
+            let managed = null;
+            try {
+                managed = await (0, config_1.readManagedConfig)();
+            }
+            catch (error) {
+                if (!(error instanceof errors_1.ManagedConfigMissingError))
+                    throw error;
+            }
+            const apiKey = (flags["api-key"] ?? managed?.apiKey ?? "").trim();
+            if (!apiKey) {
+                throw new Error('API key is required. Run "theclawbay setup --api-key <key>".');
+            }
+            const backendRaw = flags.backend ?? (0, api_key_1.tryInferBackendUrlFromApiKey)(apiKey) ?? managed?.backendUrl ?? DEFAULT_BACKEND_URL;
+            const backendUrl = normalizeUrl(backendRaw, "--backend");
+            const clientChoice = await resolveClientChoice(flags.client);
+            const codexWanted = clientChoice === "codex" || clientChoice === "both";
+            const openClawWanted = clientChoice === "openclaw" || clientChoice === "both";
+            await (0, config_1.writeManagedConfig)({ backendUrl, apiKey });
+            let codexConfigPath = null;
+            if (codexWanted) {
+                codexConfigPath = await writeCodexConfig({
+                    backendUrl,
+                    providerId: flags.provider.trim() || DEFAULT_PROVIDER_ID,
+                    openaiSync: flags["openai-sync"],
+                });
+            }
+            if (codexWanted && !flags["skip-login"]) {
+                if (!hasCommand("codex")) {
+                    throw new Error('codex CLI not found. Install @openai/codex, or run setup with --client openclaw.');
+                }
+                codexLoginWithApiKey(apiKey);
+            }
+            if (openClawWanted) {
+                if (!hasCommand("openclaw")) {
+                    throw new Error('openclaw CLI not found. Install OpenClaw, or run setup with --client codex.');
+                }
+                setupOpenClaw({
+                    backendUrl,
+                    apiKey,
+                    model: flags["openclaw-model"],
+                });
+            }
+            this.log(`Linked. Managed config written to ${paths_1.managedConfigPath}`);
+            this.log(`Backend: ${backendUrl}`);
+            if (codexConfigPath) {
+                this.log(`Codex config updated at ${codexConfigPath}`);
+                if (flags["openai-sync"]) {
+                    this.log("Codex configured in OpenAI-sync mode (ChatGPT-linked history view).");
+                }
+                else {
+                    this.log("Codex configured in local-history mode (default).");
+                }
+            }
+            if (openClawWanted) {
+                this.log("OpenClaw model provider updated for direct WAN API-key routing.");
+            }
+            if (codexWanted && flags["skip-login"]) {
+                this.log("Skipped Codex login. Run: printenv OPENAI_API_KEY | codex login --with-api-key");
+            }
+            else if (codexWanted) {
+                this.log("Codex API-key login updated.");
+            }
+            this.log('Done. Users can run directly (no "theclawbay proxy" required in recommended setup).');
+        });
+    }
+}
+SetupCommand.description = "One-time direct setup for Codex/OpenClaw: link key and route directly to The Claw Bay backend";
+SetupCommand.flags = {
+    backend: core_1.Flags.string({
+        required: false,
+        description: "Backend base URL override (default: https://theclawbay.com)",
+    }),
+    "api-key": core_1.Flags.string({
+        required: false,
+        aliases: ["apiKey"],
+        description: "API key issued by your The Claw Bay dashboard",
+    }),
+    provider: core_1.Flags.string({
+        required: false,
+        default: DEFAULT_PROVIDER_ID,
+        description: "Codex model provider id to write into ~/.codex/config.toml",
+    }),
+    client: core_1.Flags.string({
+        required: false,
+        default: "auto",
+        options: ["auto", "codex", "openclaw", "both"],
+        description: "Client target to configure",
+    }),
+    "openclaw-model": core_1.Flags.string({
+        required: false,
+        default: DEFAULT_OPENCLAW_MODEL,
+        description: "OpenClaw model id to set as default (without provider prefix)",
+    }),
+    "skip-login": core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Skip `codex login --with-api-key`",
+    }),
+    "openai-sync": core_1.Flags.boolean({
+        required: false,
+        default: false,
+        description: "Enable OpenAI-synced conversation mode (writes chatgpt_base_url/requires_openai_auth); may prefer remote ChatGPT history over local-only history",
+    }),
+};
+exports.default = SetupCommand;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "theclawbay",
-  "version": "0.2.1",
-  "description": "The Claw Bay CLI: link an API key and run a local relay to The Claw Bay backend.",
+  "version": "0.2.4",
+  "description": "The Claw Bay CLI: one-time API-key setup for direct Codex access, with optional relay fallback.",
   "license": "MIT",
   "bin": {
     "theclawbay": "dist/index.js"
@@ -10,7 +10,11 @@
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.json && node -e \"require('node:fs').chmodSync('dist/index.js',0o755)\"",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "release:patch": "./scripts/release-npm.sh patch",
+    "release:minor": "./scripts/release-npm.sh minor",
+    "release:major": "./scripts/release-npm.sh major",
+    "release:dry-run": "./scripts/release-npm.sh patch --dry-run"
   },
   "engines": {
     "node": ">=18"
@@ -24,6 +28,8 @@
     "codex",
     "claw-bay",
     "cli",
+    "setup",
+    "wan",
     "proxy",
     "api-key",
     "relay"