usertold 1.9.1 → 1.9.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usertold",
-  "version": "1.9.1",
+  "version": "1.9.3",
   "description": "UserTold.ai CLI",
   "license": "UNLICENSED",
   "type": "module",

package/usertold

@@ -310,8 +310,8 @@ class HttpError extends CliError {
         this.details = details;
     }
 }
-async function requestJson(input) {
-    const response = await requestRaw(input);
+async function requestJson(input, retryOptions) {
+    const response = await requestRaw(input, retryOptions);
     if (!response.ok) {
         throw new HttpError(response.status, extractErrorDetails(response));
     }
@@ -371,7 +371,7 @@ async function requestJson(input) {
     const arrayBuffer = await response.arrayBuffer();
     return Buffer.from(arrayBuffer);
 }
-async function requestRaw(input) {
+async function requestRaw(input, retryOptions) {
     const method = input.method.toUpperCase();
     const authMode = input.authMode ?? 'required';
     const headers = {
@@ -395,21 +395,41 @@ async function requestRaw(input) {
     }
     const baseUrl = resolveBaseUrl(input.env);
     const path = input.path.startsWith('/') ? input.path : `/${input.path}`;
-    const response = await fetch(`${baseUrl}${path}`, {
-        method,
-        headers,
-        body
-    });
-    const text = await response.text();
-    const contentType = response.headers.get('content-type') ?? '';
-    const json = contentType.includes('application/json') && text.length > 0 ? safeParseJson(text) : null;
-    return {
-        status: response.status,
-        ok: response.ok,
-        headers: response.headers,
-        text,
-        json
-    };
+    const url = `${baseUrl}${path}`;
+    const retries = retryOptions?.retries ?? 0;
+    const initialDelayMs = retryOptions?.initialDelayMs ?? 500;
+    const maxDelayMs = retryOptions?.maxDelayMs ?? 4_000;
+    let delayMs = initialDelayMs;
+    let lastError;
+    for(let attempt = 0; attempt <= retries; attempt++){
+        try {
+            const response = await fetch(url, {
+                method,
+                headers,
+                body
+            });
+            const parsed = await toApiResponse(response);
+            if (attempt >= retries || !retryOptions?.shouldRetry?.({
+                attempt,
+                response: parsed
+            })) {
+                return parsed;
+            }
+            const retryAfterMs = parseRetryAfterMs(parsed.headers.get('Retry-After'));
+            await sleep$1(jitter$1(retryAfterMs ?? delayMs));
+        } catch (error) {
+            lastError = error;
+            if (attempt >= retries || !retryOptions?.shouldRetry?.({
+                attempt,
+                error
+            })) {
+                throw error;
+            }
+            await sleep$1(jitter$1(delayMs));
+        }
+        delayMs = Math.min(maxDelayMs, delayMs * 2);
+    }
+    throw lastError ?? new Error('Request failed');
 }
 async function resolveToken(env, authMode) {
     if (authMode === 'none') {
@@ -435,6 +455,9 @@ async function resolveToken(env, authMode) {
     return config.token.accessToken;
 }
 function extractErrorDetails(response) {
+    if (isCloudflare1010Response(response)) {
+        return 'Cloudflare blocked this request (error 1010). Wait a few seconds and retry, or run pushes sequentially.';
+    }
     if (response.json && typeof response.json === 'object' && response.json !== null) {
         const body = response.json;
         const maybeErrorCode = body.error_code;
@@ -472,6 +495,43 @@ function safeParseJson(text) {
         return null;
     }
 }
+async function toApiResponse(response) {
+    const text = await response.text();
+    const contentType = response.headers.get('content-type') ?? '';
+    const json = contentType.includes('application/json') && text.length > 0 ? safeParseJson(text) : null;
+    return {
+        status: response.status,
+        ok: response.ok,
+        headers: response.headers,
+        text,
+        json
+    };
+}
+function parseRetryAfterMs(value) {
+    if (!value) return null;
+    const seconds = Number(value);
+    if (!Number.isNaN(seconds) && seconds >= 0) {
+        return seconds * 1000;
+    }
+    const dateMs = Date.parse(value);
+    if (Number.isNaN(dateMs)) {
+        return null;
+    }
+    return Math.max(0, dateMs - Date.now());
+}
+function jitter$1(ms) {
+    return ms * (0.7 + Math.random() * 0.6);
+}
+function sleep$1(ms) {
+    return new Promise((resolve)=>setTimeout(resolve, ms));
+}
+function isCloudflare1010Response(response) {
+    const text = response.text.toLowerCase();
+    if (text.includes('error code 1010') || text.includes('error code: 1010')) {
+        return true;
+    }
+    return text.includes('access denied') && text.includes("browser's signature");
+}
 
 /**
  * Returns true when output should be JSON:
@@ -668,79 +728,98 @@ function generateState() {
 function base64UrlEncode(buffer) {
     return buffer.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
 }
-async function waitForAuthorizationCode(port, expectedState) {
-    return new Promise((resolve, reject)=>{
-        const server = http.createServer((req, res)=>{
-            if (!req.url) {
-                res.writeHead(400, {
-                    'Content-Type': 'text/html'
-                });
-                res.end(getErrorPage('invalid_request', 'Invalid request'));
-                return;
-            }
-            const url = new URL(req.url, `http://127.0.0.1:${port}`);
-            if (url.pathname !== '/callback') {
-                res.writeHead(404, {
-                    'Content-Type': 'text/html'
-                });
-                res.end(getErrorPage('not_found', 'Page not found'));
-                return;
-            }
-            const code = url.searchParams.get('code');
-            const state = url.searchParams.get('state');
-            const error = url.searchParams.get('error');
-            const errorDescription = url.searchParams.get('error_description');
-            // Handle OAuth error response
-            if (error) {
-                res.writeHead(400, {
-                    'Content-Type': 'text/html'
-                });
-                res.end(getErrorPage(error, errorDescription || undefined));
-                clearTimeout(timeout);
-                server.close();
-                reject(new Error(`OAuth error: ${error}${errorDescription ? ` - ${errorDescription}` : ''}`));
-                return;
-            }
-            if (!code) {
-                res.writeHead(400, {
-                    'Content-Type': 'text/html'
-                });
-                res.end(getErrorPage('invalid_request', 'Missing authorization code'));
-                clearTimeout(timeout);
-                server.close();
-                reject(new Error('Missing authorization code'));
-                return;
-            }
-            if (state !== expectedState) {
-                res.writeHead(400, {
-                    'Content-Type': 'text/html'
-                });
-                res.end(getErrorPage('invalid_request', 'State parameter mismatch - possible CSRF attack'));
-                clearTimeout(timeout);
-                server.close();
-                reject(new Error('State mismatch'));
-                return;
-            }
-            res.writeHead(200, {
+function startAuthorizationCodeListener(port, expectedState) {
+    const server = http.createServer((req, res)=>{
+        if (!req.url) {
+            res.writeHead(400, {
                 'Content-Type': 'text/html'
             });
-            res.end(getSuccessPage());
+            res.end(getErrorPage('invalid_request', 'Invalid request'));
+            return;
+        }
+        const url = new URL(req.url, `http://127.0.0.1:${port}`);
+        if (url.pathname !== '/callback') {
+            res.writeHead(404, {
+                'Content-Type': 'text/html'
+            });
+            res.end(getErrorPage('not_found', 'Page not found'));
+            return;
+        }
+        const code = url.searchParams.get('code');
+        const state = url.searchParams.get('state');
+        const error = url.searchParams.get('error');
+        const errorDescription = url.searchParams.get('error_description');
+        // Handle OAuth error response
+        if (error) {
+            res.writeHead(400, {
+                'Content-Type': 'text/html'
+            });
+            res.end(getErrorPage(error, errorDescription || undefined));
             clearTimeout(timeout);
             server.close();
-            resolve({
-                code
+            rejectResult(new Error(`OAuth error: ${error}${errorDescription ? ` - ${errorDescription}` : ''}`));
+            return;
+        }
+        if (!code) {
+            res.writeHead(400, {
+                'Content-Type': 'text/html'
+            });
+            res.end(getErrorPage('invalid_request', 'Missing authorization code'));
+            clearTimeout(timeout);
+            server.close();
+            rejectResult(new Error('Missing authorization code'));
+            return;
+        }
+        if (state !== expectedState) {
+            res.writeHead(400, {
+                'Content-Type': 'text/html'
             });
+            res.end(getErrorPage('invalid_request', 'State parameter mismatch - possible CSRF attack'));
+            clearTimeout(timeout);
+            server.close();
+            rejectResult(new Error('State mismatch'));
+            return;
+        }
+        res.writeHead(200, {
+            'Content-Type': 'text/html'
+        });
+        res.end(getSuccessPage());
+        clearTimeout(timeout);
+        server.close();
+        resolveResult({
+            code
         });
-        server.listen(port, '127.0.0.1');
-        server.on('error', (error)=>{
+    });
+    let rejectResult = ()=>{};
+    let resolveResult = ()=>{};
+    const result = new Promise((resolve, reject)=>{
+        resolveResult = resolve;
+        rejectResult = reject;
+    });
+    const ready = new Promise((resolve, reject)=>{
+        const handleStartupError = (error)=>{
             clearTimeout(timeout);
+            rejectResult(new Error(`Failed to start local callback server: ${error.message}`));
             reject(new Error(`Failed to start local callback server: ${error.message}`));
+        };
+        server.once('error', handleStartupError);
+        server.listen(port, '127.0.0.1', ()=>{
+            server.off('error', handleStartupError);
+            server.on('error', (error)=>{
+                clearTimeout(timeout);
+                rejectResult(new Error(`Local callback server error: ${error.message}`));
+            });
+            resolve();
         });
-        const timeout = setTimeout(()=>{
-            server.close();
-            reject(new Error('Login timed out waiting for authorization response'));
-        }, 5 * 60 * 1000);
     });
+    const timeout = setTimeout(()=>{
+        server.close();
+        rejectResult(new Error('Login timed out waiting for authorization response'));
+    }, 5 * 60 * 1000);
+    return {
+        ready,
+        result
+    };
 }
 // =============================================================================
 // CLI Auth Page Design Tokens
@@ -992,6 +1071,8 @@ async function handleLogin(parsed) {
     authUrl.searchParams.set('code_challenge_method', 'S256');
     authUrl.searchParams.set('state', state);
     authUrl.searchParams.set('access_type', 'offline');
+    const authorizationCodeListener = startAuthorizationCodeListener(redirectPort, state);
+    await authorizationCodeListener.ready;
     // Always print the URL so it works on headless/remote hosts
     console.log('\nOpen this URL in your browser to authenticate:\n');
     console.log(authUrl.toString());
@@ -1008,7 +1089,7 @@ async function handleLogin(parsed) {
             console.log('(Could not open browser — use the URL above)');
         }
     }
-    const { code } = await waitForAuthorizationCode(redirectPort, state);
+    const { code } = await authorizationCodeListener.result;
     console.log('Received authorization code. Exchanging for access token...');
     const tokenResponse = await exchangeCodeForToken({
         baseUrl,
@@ -9280,7 +9361,8 @@ function requestProjectContract(options) {
         body: options.body,
         authMode: options.authMode,
         projectKey: options.projectKey,
-        headers: options.headers
+        headers: options.headers,
+        retryOptions: options.retryOptions
     };
     return doRequestContract({
         env: options.env
@@ -9347,7 +9429,7 @@ async function doRequestContract(defaults, key, options) {
         authMode: options.authMode ?? defaults.authMode,
         projectKey: options.projectKey ?? defaults.projectKey,
         headers: mergeHeaders(defaults.headers, options.headers)
-    });
+    }, options.retryOptions);
 }
 function mergeHeaders(defaults, overrides) {
     if (!defaults && !overrides) {
@@ -11050,6 +11132,12 @@ const FLAGS$a = {
     ],
     'push-status': []
 };
+const TASK_PUSH_RETRY_OPTIONS = {
+    retries: 4,
+    initialDelayMs: 500,
+    maxDelayMs: 4_000,
+    shouldRetry: ({ response, error })=>isRetryableTaskPushFailure(response, error)
+};
 async function handleTaskCommand(subcommand, parsed) {
     if (!subcommand || hasHelpFlag(parsed) || subcommand === 'help' || subcommand === '--help' || subcommand === '-h') {
         printTaskHelp();
@@ -11279,7 +11367,8 @@ async function handleTaskCommand(subcommand, parsed) {
                     sourceLabel: '<projectRef>',
                     pathParams: {
                         taskId: taskId
-                    }
+                    },
+                    retryOptions: TASK_PUSH_RETRY_OPTIONS
                 });
                 printOutput(data, parsed);
                 return;
@@ -11354,6 +11443,18 @@ Examples:
 function printTaskHelp() {
     console.log(TASK_HELP);
 }
+function isRetryableTaskPushFailure(response, error) {
+    if (response) {
+        if (response.status === 429) {
+            return true;
+        }
+        if (response.status >= 500 && response.status <= 504) {
+            return true;
+        }
+        return response.status === 403 && isCloudflare1010Response(response);
+    }
+    return error instanceof Error;
+}
 
 const FLAGS$9 = {
     list: [],
@@ -14633,7 +14734,7 @@ function printExtractHelp() {
     console.log(EXTRACT_HELP);
 }
 
-const CLI_VERSION$1 = '1.9.1';
+const CLI_VERSION$1 = '1.9.3';
 const GLOBAL_FLAGS = [
     'env',
     'json',
@@ -14929,7 +15030,7 @@ function printCompletionsHelp() {
     console.log(COMPLETIONS_HELP);
 }
 
-const CLI_VERSION = '1.9.1';
+const CLI_VERSION = '1.9.3';
 function detectJsonMode() {
     const argv = process$2.argv.slice(2);
     if (argv.includes('--json')) return true;