clixad 0.0.1-beta.19 → 0.0.1-beta.20

package/dist/clixad.mjs

@@ -56,6 +56,68 @@ function edgeBlockMessage(block, outcome) {
   Request id (for support): ${block.rayId}` : "";
   return head + tail + id;
 }
+function isOutageStatus(status) {
+  return OUTAGE_STATUSES.has(status);
+}
+function detectEdgeOutage(status, headers, body) {
+  if (!OUTAGE_STATUSES.has(status)) return void 0;
+  if (isGatewayError(body)) return void 0;
+  const kind = status === 502 || status === 504 ? "interrupted" : "unreachable";
+  const via = headers.get("server") ?? void 0;
+  const ray = rayId(headers, body);
+  const wait = retryAfterMs(headers);
+  return {
+    status,
+    kind,
+    ...ray ? { rayId: ray } : {},
+    ...via ? { via } : {},
+    ...wait !== void 0 ? { retryAfterMs: wait } : {}
+  };
+}
+function retryAfterMs(headers) {
+  const raw = headers.get("retry-after");
+  if (!raw) return void 0;
+  const seconds = Number(raw.trim());
+  if (!Number.isFinite(seconds) || seconds < 0) return void 0;
+  return Math.min(seconds * 1e3, MAX_RETRY_AFTER_MS);
+}
+function outageBackoffMs(attempt) {
+  return 1e3 * 2 ** attempt;
+}
+function outageWaitMs(attempt, outage) {
+  return Math.max(outage.retryAfterMs ?? 0, outageBackoffMs(attempt));
+}
+function outageWaitNotice(outage) {
+  return `  The gateway did not answer that request (${edgeOutageSummary(outage)}).
+  Nothing reached Clixad and nothing was charged. Waiting for it to come
+  back and resending \u2014 esc stops.`;
+}
+function edgeOutageSummary(outage) {
+  const parts = [`${outage.status} from ${outage.via ?? "an intermediary"}`];
+  if (outage.rayId) parts.push(`ray ${outage.rayId}`);
+  return parts.join(", ");
+}
+function edgeOutageMessage(outage, resends, healthUrl) {
+  if (outage.kind === "interrupted") {
+    return `Something in front of the gateway ended that request (${outage.status}) before an
+  answer came back. Unlike a 503 it may have reached Clixad first, so the turn
+  may have been generated and charged even though nothing arrived \u2014 that is why
+  it was not resent automatically.
+  Check /wallet, then send the message again. The conversation is intact.` + raySuffix(outage);
+  }
+  const tried = resends.count > 0 ? `
+  It was resent ${resends.count} time${resends.count === 1 ? "" : "s"} over about ${Math.round(resends.waitedMs / 1e3)}s and answered the same way.` : "";
+  const check = healthUrl ? `
+  ${healthUrl} says whether it is up.` : "";
+  return `The gateway did not answer that request (${outage.status}), so it never reached
+  Clixad. Nothing was sent to a model and nothing was charged.${tried}
+  This is the gateway being restarted or unreachable, not anything about the
+  conversation \u2014 so do not /clear it. Send the message again in a minute.${check}` + raySuffix(outage);
+}
+function raySuffix(outage) {
+  return outage.rayId ? `
+  Request id (for support): ${outage.rayId}` : "";
+}
 function safeDetail(body, limit = DETAIL_LIMIT) {
   if (!body) return "";
   const title = /<title[^>]*>([^<]*)<\/title>/i.exec(body)?.[1];
@@ -68,10 +130,23 @@ async function peek(res) {
   const body = await res.text().catch(() => "");
   return { body, res: new Response(body, { status: res.status, headers: res.headers }) };
 }
-var EdgeBlockedError, DETAIL_LIMIT;
+var OUTAGE_STATUSES, MAX_RETRY_AFTER_MS, OUTAGE_RETRIES, EdgeOutageError, EdgeBlockedError, DETAIL_LIMIT;
 var init_edge = __esm({
   "src/edge.ts"() {
     "use strict";
+    OUTAGE_STATUSES = /* @__PURE__ */ new Set([429, 502, 503, 504]);
+    MAX_RETRY_AFTER_MS = 3e4;
+    OUTAGE_RETRIES = 5;
+    EdgeOutageError = class extends Error {
+      constructor(outage, resends, healthUrl) {
+        super(edgeOutageMessage(outage, resends, healthUrl));
+        this.outage = outage;
+        this.resends = resends;
+        this.name = "EdgeOutageError";
+      }
+      outage;
+      resends;
+    };
     EdgeBlockedError = class extends Error {
       constructor(block, outcome) {
         super(edgeBlockMessage(block, outcome));
@@ -207,6 +282,22 @@ async function httpFailure(res, what) {
   const detail = safeDetail(await res.text().catch(() => ""));
   return detail ? `${what} failed: ${res.status} \u2014 ${detail}` : `${what} failed: ${res.status}`;
 }
+function sleep(ms, signal) {
+  return new Promise((resolve2) => {
+    if (!signal) {
+      setTimeout(resolve2, ms);
+      return;
+    }
+    if (signal.aborted) return resolve2();
+    const done = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
 function freeMeta(meta) {
   if (meta.free !== true) return {};
   return {
@@ -719,7 +810,50 @@ var init_client = __esm({
         });
       }
       /**
-       * POST a chat request, and get past the edge if the edge is in the way.
+       * POST a chat request, and keep asking while the answer is the edge's rather
+       * than the gateway's.
+       *
+       * Two failures live in front of this route and they are opposites, which is
+       * why they are two layers rather than one. The WAF's 403 is *deterministic* —
+       * the same bytes are blocked identically forever — so `postPastTheFilter`
+       * below changes the bytes exactly once and never merely asks again. An
+       * outage is the reverse: nothing about the request caused it, so nothing
+       * about the request can avoid it, and asking again is the only move there is.
+       *
+       * Which outages may be asked again is `EdgeOutage.kind`'s decision, not this
+       * loop's: `unreachable` never reached the gateway, `interrupted` may have
+       * been generated and billed into a connection that had already gone.
+       *
+       * The two notices are the price of a locked keyboard. A turn that sits silent
+       * for half a minute is indistinguishable from a hung one, so the wait is
+       * announced before it starts and its end is announced when the answer finally
+       * comes from the gateway.
+       */
+      async postChat(payload, signal) {
+        const resends = { count: 0, waitedMs: 0 };
+        for (; ; ) {
+          const res = await this.postPastTheFilter(payload, signal);
+          if (!isOutageStatus(res.status)) {
+            if (resends.count > 0) {
+              this.onNotice?.("  The gateway is answering again \u2014 the request went through.");
+            }
+            return res;
+          }
+          const peeked = await peek(res);
+          const outage = detectEdgeOutage(res.status, res.headers, peeked.body);
+          if (!outage) return peeked.res;
+          const health = `${this.config.gatewayUrl}/healthz`;
+          if (outage.kind === "interrupted") throw new EdgeOutageError(outage, resends, health);
+          if (resends.count >= OUTAGE_RETRIES) throw new EdgeOutageError(outage, resends, health);
+          if (resends.count === 0) this.onNotice?.(outageWaitNotice(outage));
+          const wait = outageWaitMs(resends.count, outage);
+          await sleep(wait, signal);
+          resends.count++;
+          resends.waitedMs += wait;
+        }
+      }
+      /**
+       * One POST, past the security filter if the filter is in the way.
        *
        * Plain JSON first, always, on every fresh process. That is the OpenAI-compatible
        * contract this route serves — Kimi CLI's kosong client speaks it, and so does
@@ -731,15 +865,19 @@ var init_client = __esm({
        * The retry is not a general "try again": a 403 from a WAF is deterministic,
        * and resending the identical bytes would be blocked identically. It is the
        * *same* request in a form the filter has nothing to match on, which is why it
-       * is worth exactly one attempt and no more.
+       * is worth exactly one attempt and no more. General "try again" is `postChat`
+       * above, around this, for the failure where it is the right answer.
        *
-       * Three outcomes, and each has to be distinguishable or the user is left
+       * Four outcomes, and each has to be distinguishable or the user is left
        * guessing: the retry works (stick with it, say so once), the gateway answers
        * 415 because it predates this (say that — the fix is a deploy, not a
-       * `/clear`), or it is blocked again (say that too, and say that clearing the
-       * history is the way out, because the history is what keeps triggering it).
+       * `/clear`), it is blocked again (say that too, and say that clearing the
+       * history is the way out, because the history is what keeps triggering it), or
+       * the edge answers instead of the gateway — in which case nothing is claimed
+       * and nothing is remembered, because a 503 from a router says nothing at all
+       * about whether the filter would have let that body through.
        */
-      async postChat(payload, signal) {
+      async postPastTheFilter(payload, signal) {
         const already = this.chatTransport === "encoded";
         const first = await this.sendChat(payload, already, signal);
         if (first.status !== 403) return first;
@@ -753,6 +891,7 @@ var init_client = __esm({
           if (second.block) throw new EdgeBlockedError(second.block, "retried");
           return second.res;
         }
+        if (isOutageStatus(retry.status)) return retry;
         this.chatTransport = "encoded";
         this.onNotice?.(
           `  A security filter in front of the gateway blocked that request (${edgeBlockSummary(block)}).
@@ -1063,7 +1202,7 @@ async function githubLogin(client, config, start, invite, report, signal) {
   const deadline = Date.now() + start.expires_in * 1e3;
   let interval = Math.max(start.interval, 1);
   while (Date.now() < deadline) {
-    await sleep(interval * 1e3, signal);
+    await sleep2(interval * 1e3, signal);
     if (signal?.aborted) return { status: "aborted" };
     report.tick?.();
     const poll = await client.devicePoll(start.session, invite);
@@ -1114,7 +1253,7 @@ async function devLogin(client, config, email, invite) {
   saveConfig(config);
   return { status: "ok", account: { email: res.email, balance: res.balance, created: true } };
 }
-function sleep(ms, signal) {
+function sleep2(ms, signal) {
   return new Promise((resolve2) => {
     if (!signal) {
       setTimeout(resolve2, ms);
@@ -2659,7 +2798,7 @@ function isBinary(bytes) {
   }
   return head.length > 0 && control / head.length > 0.15;
 }
-function sleep2(ms, signal) {
+function sleep3(ms, signal) {
   return new Promise((done) => {
     if (signal?.aborted) return done();
     const finish = () => {
@@ -3132,7 +3271,7 @@ ${body2}` + (pdf.text.length > MAX_FILE_BYTES ? "\n\u2026 [truncated]" : "");
         } catch (err) {
           asToolError(err);
         }
-        await sleep2(BACKGROUND_SETTLE_MS, ctx.signal);
+        await sleep3(BACKGROUND_SETTLE_MS, ctx.signal);
         const first = registry.read(started.id);
         ctx.onOutput?.(first.output);
         return `Started in the background as ${started.id}.
@@ -5883,7 +6022,7 @@ ${NO_SEARCH_INSTRUCTION}`),
     await runBusy(WAITING_FOR_REWARD, async (signal) => {
       const deadline = Date.now() + 5 * 6e4;
       while (Date.now() < deadline && !credited && !signal.aborted) {
-        await sleep3(3e3, signal);
+        await sleep4(3e3, signal);
         if (signal.aborted) break;
         const w = await client.wallet(signal).catch(() => void 0);
         if (w && w.balance > before) {
@@ -6705,7 +6844,7 @@ ${dropped.map((l) => `  \xB7 ${l}`).join("\n")}`
     ] })
   ] });
 }
-function sleep3(ms, signal) {
+function sleep4(ms, signal) {
   return new Promise((resolve2) => {
     if (signal.aborted) return resolve2();
     const done = () => {
@@ -7093,7 +7232,7 @@ function wrapPlain(text, width) {
   if (line2) lines.push(line2);
   return lines;
 }
-var sleep4 = (ms) => new Promise((r) => setTimeout(r, ms));
+var sleep5 = (ms) => new Promise((r) => setTimeout(r, ms));
 var credits = (n) => n.toLocaleString("en-US");
 function logout(config) {
   for (const key of IDENTITY_KEYS) delete config[key];
@@ -7183,7 +7322,7 @@ async function earn(client, config) {
   if (c.enabled) process.stdout.write(c.dim("  waiting for an offer to clear"));
   const deadline = Date.now() + 5 * 60 * 1e3;
   while (Date.now() < deadline) {
-    await sleep4(3e3);
+    await sleep5(3e3);
     if (c.enabled) process.stdout.write(c.dim("."));
     const balance = (await safeWallet(client))?.balance ?? before;
     if (balance > before) {
@@ -7272,7 +7411,7 @@ async function buyCmd(client, config, pack) {
   if (c.enabled) process.stdout.write(c.dim("  waiting for payment to clear"));
   const deadline = Date.now() + 5 * 60 * 1e3;
   while (Date.now() < deadline) {
-    await sleep4(3e3);
+    await sleep5(3e3);
     if (c.enabled) process.stdout.write(c.dim("."));
     const balance = (await safeWallet(client))?.balance ?? before;
     if (balance > before) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clixad",
-  "version": "0.0.1-beta.19",
+  "version": "0.0.1-beta.20",
   "description": "Free AI coding agent in your terminal, funded by rewarded ads.",
   "license": "UNLICENSED",
   "type": "module",