theclawbay 0.3.45 → 0.3.47

package/dist/commands/logout.js

@@ -43,7 +43,10 @@ const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set([
     DEFAULT_PROVIDER_ID,
 ]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = [DEFAULT_PROVIDER_ID, WAN_PROVIDER_ID];
-const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const LEGACY_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/v1";
+const THECLAWBAY_CANONICAL_API_HOST = "api.theclawbay.com";
+const THECLAWBAY_WEBSITE_HOSTS = new Set(["theclawbay.com", "www.theclawbay.com"]);
 const SUPPORTED_MODEL_IDS = new Set((0, supported_models_1.getSupportedModelIds)());
 const CONTINUE_MODEL_NAME = "The Claw Bay";
 const TRAE_PATCH_MARKER = "theclawbay-trae-patch";
@@ -166,7 +169,28 @@ function objectRecordOr(value, fallback) {
     return fallback;
 }
 function isTheClawBayOpenAiCompatibleBaseUrl(value) {
-    return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        const hostname = parsed.hostname.toLowerCase();
+        const pathname = parsed.pathname.replace(/\/+$/g, "");
+        if (pathname === LEGACY_THECLAWBAY_OPENAI_PROXY_SUFFIX &&
+            (THECLAWBAY_WEBSITE_HOSTS.has(hostname) ||
+                hostname === "localhost" ||
+                hostname === "127.0.0.1" ||
+                hostname === "::1")) {
+            return true;
+        }
+        return (hostname === THECLAWBAY_CANONICAL_API_HOST &&
+            pathname === CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX);
+    }
+    catch {
+        return false;
+    }
 }
 function uniqueStrings(values) {
     const output = [];

package/dist/commands/setup.js

@@ -39,6 +39,8 @@ const DEFAULT_ZO_MODEL = DEFAULT_CODEX_MODEL;
 const DEFAULT_MODELS = [...SUPPORTED_MODEL_IDS];
 const PREFERRED_MODELS = [...SUPPORTED_MODEL_IDS];
 const ENV_KEY_NAME = "THECLAWBAY_API_KEY";
+const CLAUDE_ENV_API_KEY_NAME = "ANTHROPIC_API_KEY";
+const CLAUDE_ENV_BASE_URL_NAME = "ANTHROPIC_BASE_URL";
 const ENV_FILE = node_path_1.default.join(paths_1.theclawbayConfigDir, "env");
 const CONTINUE_CONFIG_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".continue", "config.yaml");
 const CLINE_GLOBAL_STATE_PATH = node_path_1.default.join(node_os_1.default.homedir(), ".cline", "data", "globalState.json");
@@ -60,7 +62,11 @@ const OPENCLAW_PROVIDER_ID = DEFAULT_PROVIDER_ID;
 const HISTORY_PROVIDER_NEUTRALIZE_SOURCES = new Set(["openai", "theclawbay-wan", DEFAULT_PROVIDER_ID]);
 const HISTORY_PROVIDER_DB_MIGRATE_SOURCES = ["openai", "theclawbay-wan"];
 const SETUP_CLIENT_IDS = ["codex", "continue", "cline", "openclaw", "opencode", "kilo", "roo", "trae", "aider", "zo"];
-const THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const LEGACY_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/api/codex-auth/v1/proxy/v1";
+const CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX = "/v1";
+const CANONICAL_CODEX_NATIVE_PROXY_SUFFIX = "/backend-api/codex";
+const THECLAWBAY_CANONICAL_API_HOST = "api.theclawbay.com";
+const THECLAWBAY_WEBSITE_HOSTS = new Set(["theclawbay.com", "www.theclawbay.com"]);
 const CONTINUE_MODEL_NAME = "The Claw Bay";
 const ROO_PROFILE_NAME = "The Claw Bay";
 const ROO_PROFILE_ID = "theclawbay-openai-compatible";
@@ -303,7 +309,7 @@ async function configureZoByok(params) {
         throw new Error("Zo was detected, but no active Zo desktop session token could be read. Open Zo, sign in, and rerun setup.");
     }
     const desiredName = `${ZO_CONFIG_NAME_PREFIX} ${modelDisplayName(params.model)}`;
-    const desiredBaseUrl = `${trimTrailingSlash(params.backendUrl)}${THECLAWBAY_OPENAI_PROXY_SUFFIX}`;
+    const desiredBaseUrl = openAiCompatibleProxyUrl(params.backendUrl);
     const body = {
         provider: "openai-style",
         format: "openai",
@@ -449,11 +455,51 @@ function shellQuote(value) {
 function modelDisplayName(modelId) {
     return MODEL_DISPLAY_NAMES[modelId] ?? modelId;
 }
+function publicApiOriginForBackendUrl(backendUrl) {
+    const trimmed = trimTrailingSlash(backendUrl);
+    try {
+        const parsed = new URL(trimmed);
+        parsed.hash = "";
+        parsed.search = "";
+        parsed.pathname = "";
+        if (THECLAWBAY_WEBSITE_HOSTS.has(parsed.hostname.toLowerCase())) {
+            parsed.hostname = THECLAWBAY_CANONICAL_API_HOST;
+        }
+        return trimTrailingSlash(parsed.toString());
+    }
+    catch {
+        return trimmed;
+    }
+}
 function openAiCompatibleProxyUrl(backendUrl) {
-    return `${trimTrailingSlash(backendUrl)}${THECLAWBAY_OPENAI_PROXY_SUFFIX}`;
+    return `${publicApiOriginForBackendUrl(backendUrl)}${CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX}`;
+}
+function anthropicCompatibleProxyUrl(backendUrl) {
+    return `${publicApiOriginForBackendUrl(backendUrl)}/anthropic`;
 }
 function isTheClawBayOpenAiCompatibleBaseUrl(value) {
-    return typeof value === "string" && value.trim().endsWith(THECLAWBAY_OPENAI_PROXY_SUFFIX);
+    if (typeof value !== "string")
+        return false;
+    const normalized = value.trim();
+    if (!normalized)
+        return false;
+    try {
+        const parsed = new URL(normalized);
+        const hostname = parsed.hostname.toLowerCase();
+        const pathname = trimTrailingSlash(parsed.pathname);
+        if (pathname === LEGACY_THECLAWBAY_OPENAI_PROXY_SUFFIX &&
+            (THECLAWBAY_WEBSITE_HOSTS.has(hostname) ||
+                hostname === "localhost" ||
+                hostname === "127.0.0.1" ||
+                hostname === "::1")) {
+            return true;
+        }
+        return (hostname === THECLAWBAY_CANONICAL_API_HOST &&
+            pathname === CANONICAL_THECLAWBAY_OPENAI_PROXY_SUFFIX);
+    }
+    catch {
+        return false;
+    }
 }
 function uniqueStrings(values) {
     const output = [];
@@ -913,8 +959,16 @@ async function resolveDeviceLabel(params) {
         rl.close();
     }
 }
+function summarizeModelFetchFailure(detail) {
+    const normalized = detail.replace(/\s+/g, " ").trim();
+    if (!normalized)
+        return "unknown error";
+    if (normalized.length <= 140)
+        return normalized;
+    return `${normalized.slice(0, 137).trimEnd()}...`;
+}
 async function fetchBackendModelIds(backendUrl, apiKey) {
-    const url = `${trimTrailingSlash(backendUrl)}/api/codex-auth/v1/proxy/v1/models`;
+    const url = `${openAiCompatibleProxyUrl(backendUrl)}/models`;
     try {
         const response = await fetch(url, {
             headers: {
@@ -922,18 +976,95 @@ async function fetchBackendModelIds(backendUrl, apiKey) {
                 Accept: "application/json",
                 "User-Agent": CLI_HTTP_USER_AGENT,
             },
-            signal: AbortSignal.timeout(4500),
+            signal: AbortSignal.timeout(10000),
         });
-        if (!response.ok)
-            return null;
+        if (!response.ok) {
+            const responseText = await response.text().catch(() => "");
+            let detail = responseText.trim();
+            try {
+                const parsed = JSON.parse(responseText);
+                if (typeof parsed.error === "string" && parsed.error.trim()) {
+                    detail = parsed.error.trim();
+                }
+                else if (typeof parsed.code === "string" && parsed.code.trim()) {
+                    detail = parsed.code.trim();
+                }
+            }
+            catch {
+                // Keep the raw response text when the body is not JSON.
+            }
+            return {
+                ids: null,
+                failure: `HTTP ${response.status}${detail ? `: ${summarizeModelFetchFailure(detail)}` : ""}`,
+            };
+        }
         const body = (await response.json());
         const ids = (body.data ?? [])
             .map((entry) => (typeof entry.id === "string" ? entry.id.trim() : ""))
             .filter((id) => id.length > 0);
-        return ids.length ? ids : null;
+        if (!ids.length) {
+            return {
+                ids: null,
+                failure: "backend returned an empty model list",
+            };
+        }
+        return { ids };
     }
-    catch {
-        return null;
+    catch (error) {
+        return {
+            ids: null,
+            failure: summarizeModelFetchFailure(error instanceof Error ? error.message : String(error)),
+        };
+    }
+}
+async function fetchClaudeModelIds(backendUrl, apiKey) {
+    const url = `${anthropicCompatibleProxyUrl(backendUrl)}/v1/models`;
+    try {
+        const response = await fetch(url, {
+            headers: {
+                "x-api-key": apiKey,
+                Accept: "application/json",
+                "User-Agent": CLI_HTTP_USER_AGENT,
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            const responseText = await response.text().catch(() => "");
+            let detail = responseText.trim();
+            try {
+                const parsed = JSON.parse(responseText);
+                if (typeof parsed.error === "string" && parsed.error.trim()) {
+                    detail = parsed.error.trim();
+                }
+                else if (typeof parsed.code === "string" && parsed.code.trim()) {
+                    detail = parsed.code.trim();
+                }
+            }
+            catch {
+                // Keep the raw response text when the body is not JSON.
+            }
+            return {
+                ids: null,
+                failure: `HTTP ${response.status}${detail ? `: ${summarizeModelFetchFailure(detail)}` : ""}`,
+            };
+        }
+        const body = (await response.json());
+        const ids = (body.data ?? [])
+            .map((entry) => (typeof entry.id === "string" ? entry.id.trim() : ""))
+            .filter((id) => id.length > 0);
+        if (!ids.length) {
+            return {
+                ids: null,
+                failure: "backend returned an empty Claude model list",
+            };
+        }
+        return { ids };
+    }
+    catch (error) {
+        return {
+            ids: null,
+            failure: summarizeModelFetchFailure(error instanceof Error ? error.message : String(error)),
+        };
     }
 }
 function kiloStorageCandidates() {
@@ -1042,7 +1173,7 @@ async function detectZoClient() {
     return false;
 }
 async function resolveModels(backendUrl, apiKey) {
-    const ids = await fetchBackendModelIds(backendUrl, apiKey);
+    const { ids, failure } = await fetchBackendModelIds(backendUrl, apiKey);
     const available = new Set(ids ?? []);
     let selected = DEFAULT_CODEX_MODEL;
     let note;
@@ -1057,7 +1188,9 @@ async function resolveModels(backendUrl, apiKey) {
         note = "No preferred Codex model advertised by backend; selected first available model.";
     }
     else if (!ids) {
-        note = `Unable to query backend model list; defaulted to ${DEFAULT_CODEX_MODEL}.`;
+        note = failure
+            ? `Unable to query backend model list (${failure}); defaulted to ${DEFAULT_CODEX_MODEL}.`
+            : `Unable to query backend model list; defaulted to ${DEFAULT_CODEX_MODEL}.`;
     }
     const unique = [];
     const pushUnique = (modelId) => {
@@ -1076,6 +1209,20 @@ async function resolveModels(backendUrl, apiKey) {
         note,
     };
 }
+async function resolveClaudeAccess(backendUrl, apiKey) {
+    const { ids, failure } = await fetchClaudeModelIds(backendUrl, apiKey);
+    if (!ids?.length) {
+        return {
+            enabled: false,
+            models: [],
+            note: failure ? `Claude Code auto-setup skipped (${failure}).` : undefined,
+        };
+    }
+    return {
+        enabled: true,
+        models: ids,
+    };
+}
 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 });
@@ -1088,18 +1235,19 @@ async function writeCodexConfig(params) {
         if (err.code !== "ENOENT")
             throw error;
     }
-    const proxyRoot = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy`;
+    const proxyRoot = publicApiOriginForBackendUrl(params.backendUrl);
+    const nativeCodexBaseUrl = `${proxyRoot}${CANONICAL_CODEX_NATIVE_PROXY_SUFFIX}`;
     let next = existing;
     next = removeManagedBlock(next, MANAGED_START, MANAGED_END);
     next = removeProviderTable(next, DEFAULT_PROVIDER_ID);
     next = upsertFirstKeyLine(next, "model_provider", `"${DEFAULT_PROVIDER_ID}"`);
     next = upsertFirstKeyLine(next, "model", `"${params.model}"`);
+    next = upsertFirstKeyLine(next, "chatgpt_base_url", `"${proxyRoot}"`);
     const managedBlock = appendManagedBlock("", [
         MANAGED_START,
-        `chatgpt_base_url = "${proxyRoot}"`,
         `[model_providers.${DEFAULT_PROVIDER_ID}]`,
         'name = "OpenAI"',
-        `base_url = "${proxyRoot}/backend-api/codex"`,
+        `base_url = "${nativeCodexBaseUrl}"`,
         'wire_api = "responses"',
         "requires_openai_auth = true",
         "supports_websockets = true",
@@ -1250,14 +1398,17 @@ async function writeAiderConfig(params) {
     await promises_1.default.writeFile(AIDER_CONFIG_PATH, next, "utf8");
     return AIDER_CONFIG_PATH;
 }
-async function persistApiKeyEnv(apiKey) {
+async function persistApiKeyEnv(params) {
     const envDir = node_path_1.default.dirname(ENV_FILE);
     await promises_1.default.mkdir(envDir, { recursive: true });
-    const envContents = [
+    const envLines = [
         "# Generated by theclawbay setup",
-        `export ${ENV_KEY_NAME}=${shellQuote(apiKey)}`,
-        "",
-    ].join("\n");
+        `export ${ENV_KEY_NAME}=${shellQuote(params.apiKey)}`,
+    ];
+    if (params.claudeEnabled) {
+        envLines.push("", "# Official Claude Code CLI", `export ${CLAUDE_ENV_API_KEY_NAME}=${shellQuote(params.apiKey)}`, `export ${CLAUDE_ENV_BASE_URL_NAME}=${shellQuote(anthropicCompatibleProxyUrl(params.backendUrl))}`);
+    }
+    const envContents = `${envLines.join("\n")}\n`;
     await promises_1.default.writeFile(ENV_FILE, envContents, "utf8");
     await promises_1.default.chmod(ENV_FILE, 0o600);
     const sourceLine = `[ -f "$HOME/.config/theclawbay/env" ] && . "$HOME/.config/theclawbay/env"`;
@@ -1278,7 +1429,15 @@ async function persistApiKeyEnv(apiKey) {
         await promises_1.default.writeFile(rcPath, withBlock, "utf8");
         updated.push(rcPath);
     }
-    process.env[ENV_KEY_NAME] = apiKey;
+    process.env[ENV_KEY_NAME] = params.apiKey;
+    if (params.claudeEnabled) {
+        process.env[CLAUDE_ENV_API_KEY_NAME] = params.apiKey;
+        process.env[CLAUDE_ENV_BASE_URL_NAME] = anthropicCompatibleProxyUrl(params.backendUrl);
+    }
+    else {
+        delete process.env[CLAUDE_ENV_API_KEY_NAME];
+        delete process.env[CLAUDE_ENV_BASE_URL_NAME];
+    }
     return updated;
 }
 async function persistVsCodeServerEnvSource() {
@@ -1334,7 +1493,7 @@ function resolveOpenClawPrimaryModel(params) {
 }
 async function patchOpenClawConfigFile(params) {
     const provider = {
-        baseUrl: `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`,
+        baseUrl: openAiCompatibleProxyUrl(params.backendUrl),
         apiKey: params.apiKey,
         api: "openai-responses",
         models: buildOpenClawModels(params.models),
@@ -1647,7 +1806,7 @@ async function writeOpenCodeFamilyConfig(params) {
         }
         const managedOpenAiProvider = objectRecordOr(providerRoot[OPENAI_PROVIDER_ID], {});
         const optionsRoot = objectRecordOr(managedOpenAiProvider.options, {});
-        optionsRoot.baseURL = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`;
+        optionsRoot.baseURL = openAiCompatibleProxyUrl(params.backendUrl);
         optionsRoot.apiKey = params.apiKey;
         managedOpenAiProvider.options = optionsRoot;
         managedOpenAiProvider.models = buildOpenCodeModelsObject(params.models);
@@ -1689,7 +1848,7 @@ function traePatchSnippet(params) {
     const patchedModels = params.models.length
         ? params.models
         : [{ id: params.model.trim() || DEFAULT_TRAE_MODEL, name: modelDisplayName(params.model.trim() || DEFAULT_TRAE_MODEL) }];
-    const proxyBaseUrl = `${trimTrailingSlash(params.backendUrl)}/api/codex-auth/v1/proxy/v1`;
+    const proxyBaseUrl = openAiCompatibleProxyUrl(params.backendUrl);
     return `async setOriginModelListMapAndCache(e,t=!0){let{userProfile:r}=this.credentialStore.getState(),i=r?.scope!==v9.BYTEDANCE,n={},o=${JSON.stringify(patchedModels)};Object.keys(e).forEach(t=>{let r=[...(e[t]||[])],s=r[0]&&"object"==typeof r[0]?r[0]:null;if([Mh.Builder,Mh.SoloCoder].includes(t)&&s){let a=o.map((e,l)=>{let o={...s};return o.id=${JSON.stringify(TRAE_PATCH_MARKER)}+"-"+t+"-"+e.id,o.name=e.id,o.display_name=e.name,o.provider="theclawbay",o.icon={dark:"https://theclawbay.com/favicon.ico",light:"https://theclawbay.com/favicon.ico"},o.ak=${JSON.stringify(params.apiKey)},o.base_url=${JSON.stringify(proxyBaseUrl)},o.is_custom_base_url=!0,o.custom_model_id=${JSON.stringify(TRAE_PATCH_MARKER)}+"-"+e.id,o.selectable=!0,o.status=!0,o.is_default=0===l,o.config_source=MK.Personal,o.model_type=s.model_type??"chat_model",o.builder=s.builder??null,o.client_connect=!0,o.multimodal=!1!==s.multimodal,o.tags=Array.isArray(s.tags)?s.tags:[],o.auth_type="number"==typeof s.auth_type?s.auth_type:0,o.region=s.region??null,o.max_turns=s.max_turns??{default:50,max:50},o.context_window_size=s.context_window_size??{max:[128000],default:64000},o.features=s.features??{memory:{enable:!1},cost:{enable:!1,data:{manual_usage:0}},multimodal:{enable:!0},context_windows:{enable:!0,data:{dev_context:64000,max_context:128000,max_context_list:[128000],dev_turns:50,max_turns:50}}},o.commercial_info=s.commercial_info??{manual_usage:0,info:""},o.saas_usage=s.saas_usage??{max:0,default:null},o});n[t]=a;return}!i&&[Mh.SoloCoder,Mh.UIBuilder].includes(t)?n[t]=r?.filter(e=>e.config_source!==MK.Personal)||[]:n[t]=r}),this._modelStore.actions.setOriginModelListMap(n),t&&this._modelStorageService.storeModelListMap(n),this._logService.info("[ModelService.setOriginModelListMapAndCache] officialModels",Object.entries(n).map(([e,t])=>({scene:e,models:(t||[]).map(e=>e.display_name||e.name)})))}`;
 }
 async function patchTraeBundle(params) {
@@ -1895,6 +2054,7 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             const progress = this.createProgressHandle(!debugOutput);
             let resolved = null;
+            let claudeAccess = null;
             let updatedShellFiles = [];
             let codexConfigPath = null;
             let updatedVsCodeEnvFiles = [];
@@ -1918,6 +2078,8 @@ class SetupCommand extends base_command_1.BaseCommand {
                     progress.update("Resolving supported models");
                     resolved = await resolveModels(backendUrl, authCredential);
                 }
+                progress.update("Checking Claude access");
+                claudeAccess = await resolveClaudeAccess(backendUrl, authCredential);
                 progress.update("Saving shared machine config");
                 await (0, config_1.writeManagedConfig)({
                     backendUrl,
@@ -1926,7 +2088,11 @@ class SetupCommand extends base_command_1.BaseCommand {
                     deviceSessionId,
                     deviceLabel,
                 });
-                updatedShellFiles = await persistApiKeyEnv(authCredential);
+                updatedShellFiles = await persistApiKeyEnv({
+                    apiKey: authCredential,
+                    backendUrl,
+                    claudeEnabled: claudeAccess.enabled,
+                });
                 if (selectedSetupClients.has("codex")) {
                     progress.update("Configuring Codex");
                     codexConfigPath = await writeCodexConfig({
@@ -2052,6 +2218,12 @@ class SetupCommand extends base_command_1.BaseCommand {
             const summaryNotes = new Set();
             if (resolved?.note)
                 summaryNotes.add(resolved.note);
+            if (claudeAccess?.enabled) {
+                summaryNotes.add("Claude Code: exported ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY for the official client.");
+            }
+            else if (claudeAccess?.note) {
+                summaryNotes.add(claudeAccess.note);
+            }
             if (selectedSetupClients.has("trae")) {
                 summaryNotes.add("Trae uses an experimental patch. Restart Trae and pick a The Claw Bay model to test it.");
             }
@@ -2101,6 +2273,12 @@ class SetupCommand extends base_command_1.BaseCommand {
             }
             if (resolved?.note)
                 this.log(resolved.note);
+            if (claudeAccess?.enabled) {
+                this.log(`- Claude Code base URL: ${anthropicCompatibleProxyUrl(backendUrl)}`);
+            }
+            else if (claudeAccess?.note) {
+                this.log(`- Claude Code: ${claudeAccess.note}`);
+            }
             this.log(`- Local credential env: ${ENV_FILE}`);
             this.log(`- Shell profiles updated: ${updatedShellFiles.join(", ")}`);
             if (selectedSetupClients.has("codex")) {

package/dist/lib/device-session-auth.js

@@ -152,8 +152,53 @@ async function exchangeBrowserSetupSession(params) {
         deviceLabel: exchangeBody.deviceLabel,
     };
 }
-async function delay(ms) {
-    await new Promise((resolve) => setTimeout(resolve, ms));
+function createSetupAbortError() {
+    const error = new Error("browser setup cancelled");
+    error.name = "AbortError";
+    return error;
+}
+async function delay(ms, signal) {
+    if (signal?.aborted)
+        throw createSetupAbortError();
+    await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(createSetupAbortError());
+        };
+        const cleanup = () => signal?.removeEventListener("abort", onAbort);
+        signal?.addEventListener("abort", onAbort, { once: true });
+    });
+}
+async function withTimeout(promise, timeoutMs, signal) {
+    if (signal?.aborted)
+        throw createSetupAbortError();
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            reject(new Error("browser setup timed out"));
+        }, timeoutMs);
+        const onAbort = () => {
+            clearTimeout(timer);
+            cleanup();
+            reject(createSetupAbortError());
+        };
+        const cleanup = () => signal?.removeEventListener("abort", onAbort);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        promise.then((value) => {
+            clearTimeout(timer);
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            clearTimeout(timer);
+            cleanup();
+            reject(error);
+        });
+    });
 }
 async function waitForFirstSuccessfulExchange(promises) {
     return await new Promise((resolve, reject) => {
@@ -190,6 +235,8 @@ async function createBrowserLinkedDeviceSession(params) {
     const label = (params.deviceLabel ?? "").trim() || node_os_1.default.hostname() || "This device";
     const state = node_crypto_1.default.randomUUID();
     const callbackServer = await createLocalCallbackServer(state);
+    const exchangeAbortController = new AbortController();
+    const exchangeSignal = exchangeAbortController.signal;
     try {
         const startResponse = await fetch(`${params.backendUrl}/api/setup/device-session/start`, {
             method: "POST",
@@ -215,12 +262,7 @@ async function createBrowserLinkedDeviceSession(params) {
         let fallbackNoticeShown = false;
         const timeoutError = new Error("browser setup timed out");
         const waitForLocalCallbackExchange = async () => {
-            const callback = await Promise.race([
-                callbackServer.waitForCallback(),
-                new Promise((_, reject) => {
-                    setTimeout(() => reject(timeoutError), BROWSER_SETUP_TIMEOUT_MS);
-                }),
-            ]);
+            const callback = await withTimeout(callbackServer.waitForCallback(), BROWSER_SETUP_TIMEOUT_MS, exchangeSignal);
             return exchangeBrowserSetupSession({
                 backendUrl: params.backendUrl,
                 sessionId: callback.sessionId,
@@ -230,6 +272,8 @@ async function createBrowserLinkedDeviceSession(params) {
         };
         const waitForPolledExchange = async () => {
             while (Date.now() < deadlineMs) {
+                if (exchangeSignal.aborted)
+                    throw createSetupAbortError();
                 try {
                     return await exchangeBrowserSetupSession({
                         backendUrl: params.backendUrl,
@@ -247,14 +291,21 @@ async function createBrowserLinkedDeviceSession(params) {
                     params.log("Waiting for browser approval. If the browser cannot reach localhost, setup will still finish here after you connect the device.");
                     fallbackNoticeShown = true;
                 }
-                await delay(BROWSER_SETUP_POLL_INTERVAL_MS);
+                await delay(BROWSER_SETUP_POLL_INTERVAL_MS, exchangeSignal);
             }
             throw timeoutError;
         };
-        const linked = await waitForFirstSuccessfulExchange([
-            waitForLocalCallbackExchange(),
-            waitForPolledExchange(),
-        ]);
+        const linked = await (async () => {
+            try {
+                return await waitForFirstSuccessfulExchange([
+                    waitForLocalCallbackExchange(),
+                    waitForPolledExchange(),
+                ]);
+            }
+            finally {
+                exchangeAbortController.abort();
+            }
+        })();
         return {
             credential: linked.credential,
             authType: linked.authType,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "theclawbay",
-  "version": "0.3.45",
+  "version": "0.3.47",
   "description": "CLI for connecting Codex, Continue, Cline, OpenClaw, OpenCode, Kilo, Roo Code, Aider, experimental Trae, and experimental Zo to The Claw Bay.",
   "license": "MIT",
   "bin": {