theclawbay 0.3.45 → 0.3.46

package/dist/commands/setup.js

@@ -913,6 +913,14 @@ 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`;
     try {
@@ -922,18 +930,45 @@ 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)),
+        };
     }
 }
 function kiloStorageCandidates() {
@@ -1042,7 +1077,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 +1092,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) => {
@@ -1094,9 +1131,9 @@ async function writeCodexConfig(params) {
     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"`,

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.46",
   "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": {