clixad 0.0.1-beta.10 → 0.0.1-beta.11

package/dist/clixad.mjs

@@ -14,7 +14,83 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/edge.ts
+function detectEdgeBlock(status, headers, body) {
+  if (status !== 403) return void 0;
+  if (isGatewayError(body)) return void 0;
+  const via = headers.get("server") ?? void 0;
+  const ray = rayId(headers, body);
+  return { status, ...ray ? { rayId: ray } : {}, ...via ? { via } : {} };
+}
+function isGatewayError(body) {
+  try {
+    const parsed = JSON.parse(body);
+    return typeof parsed?.error === "string";
+  } catch {
+    return false;
+  }
+}
+function rayId(headers, body) {
+  const header = headers.get("cf-ray");
+  if (header) return header.split("-")[0];
+  const text = body.replace(/<[^>]*>/g, " ");
+  return /ray\s*id:?\s*([0-9a-f]{16})/i.exec(text)?.[1];
+}
+function edgeBlockSummary(block) {
+  const parts = [`${block.status} from ${block.via ?? "an intermediary"}`];
+  if (block.rayId) parts.push(`ray ${block.rayId}`);
+  return parts.join(", ");
+}
+function edgeBlockMessage(block, outcome) {
+  const head = `A security filter in front of the gateway rejected this request (${block.status}), so it
+  never reached Clixad. Nothing was sent to a model and nothing was charged.
+  Filters like that match on request contents, and a conversation about path
+  traversal, SQL or shell commands looks like an attack payload to one.`;
+  const tail = outcome === "retried" ? `
+  The compressed body this CLI falls back to was blocked as well.
+  Every turn resends the whole conversation, so the next one will be blocked
+  too \u2014 use /clear, or start a new session, to get past it.` : `
+  This gateway is too old to accept the compressed body that works around it.
+  Update the gateway, or use /clear to drop the history that trips the filter.`;
+  const id = block.rayId ? `
+  Request id (for support): ${block.rayId}` : "";
+  return head + tail + id;
+}
+function safeDetail(body, limit = DETAIL_LIMIT) {
+  if (!body) return "";
+  const title = /<title[^>]*>([^<]*)<\/title>/i.exec(body)?.[1];
+  const source = title ?? body;
+  const text = source.replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)?/g, " ").replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, " ").replace(/<[^>]*>/g, " ").replace(/[\u0000-\u001f\u007f-\u009f]/g, " ").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > limit ? `${text.slice(0, limit - 1)}\u2026` : text;
+}
+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 init_edge = __esm({
+  "src/edge.ts"() {
+    "use strict";
+    EdgeBlockedError = class extends Error {
+      constructor(block, outcome) {
+        super(edgeBlockMessage(block, outcome));
+        this.block = block;
+        this.outcome = outcome;
+        this.name = "EdgeBlockedError";
+      }
+      block;
+      outcome;
+    };
+    DETAIL_LIMIT = 200;
+  }
+});
+
 // src/client.ts
+import { gzipSync } from "node:zlib";
+function encodeChatBody(json) {
+  return gzipSync(Buffer.from(json, "utf8"));
+}
 function adsPerTaskLabel(estAdsPerTask) {
   const effort = estAdsPerTask >= 1 ? `~${estAdsPerTask} ads/task` : "<1 ad/task";
   return `${effort} on completion`;
@@ -76,6 +152,15 @@ async function authFailure(res, what) {
     `${what}: the gateway returned 401 without a Clixad error body. The gateway URL may be pointing at something else \u2014 a login/SSO page, a proxy, or a stale deployment. Check it, or set CLIXAD_GATEWAY_URL.`
   );
 }
+async function triage(res) {
+  const peeked = await peek(res);
+  const block = detectEdgeBlock(res.status, res.headers, peeked.body);
+  return { ...block ? { block } : {}, res: peeked.res };
+}
+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 accumulateToolCall(calls, part, fallbackIndex) {
   const index = part.index ?? fallbackIndex;
   const current = calls.get(index) ?? { id: "", type: "function", function: { name: "", arguments: "" } };
@@ -102,10 +187,12 @@ async function* parseSSE(body) {
     }
   }
 }
-var LEDGER_REASONS, SignupClosedError, PaywallError, AuthError, GatewayClient;
+var CHAT_ENCODED_CONTENT_TYPE, LEDGER_REASONS, SignupClosedError, PaywallError, AuthError, GatewayClient;
 var init_client = __esm({
   "src/client.ts"() {
     "use strict";
+    init_edge();
+    CHAT_ENCODED_CONTENT_TYPE = "application/vnd.clixad.chat+gzip";
     LEDGER_REASONS = {
       signup_bonus: "signup bonus",
       ad_reward: "offer reward",
@@ -148,6 +235,25 @@ var init_client = __esm({
         this.config = config;
       }
       config;
+      /**
+       * Told when the client had to change how it talks to the gateway.
+       *
+       * Set by the REPL, unset everywhere else. A transport that silently changes
+       * itself is a thing the user should be able to see — it explains the pause,
+       * and it is the difference between "the tool is being slow" and "something in
+       * front of the gateway rejected that request". Left unset for `clixad -p` and
+       * the one-shot commands, whose stdout exists to be piped.
+       */
+      onNotice;
+      /**
+       * How chat bodies are being sent, for the rest of this process.
+       *
+       * Sticky once it moves. The conversation is resent in full every turn, so the
+       * string that got the first request blocked is in every request after it —
+       * going back to plain JSON would mean paying a blocked round-trip per turn to
+       * rediscover the same thing.
+       */
+      chatTransport = "json";
       headers(auth = true) {
         const h = { "Content-Type": "application/json" };
         if (auth) {
@@ -179,7 +285,7 @@ var init_client = __esm({
           headers: this.headers(false)
         });
         if (res.status === 501) return null;
-        if (!res.ok) throw new Error(`device start failed: ${res.status} ${await res.text()}`);
+        if (!res.ok) throw new Error(await httpFailure(res, "device start"));
         return res.json();
       }
       /** Poll once for device-flow completion. `invite` unlocks a gated signup. */
@@ -229,7 +335,7 @@ var init_client = __esm({
         });
         if (res.status === 401) throw await authFailure(res, "checkout");
         if (res.status === 501) throw new Error("Buying credits isn't enabled (Stripe not configured on the gateway).");
-        if (!res.ok) throw new Error(`checkout failed: ${res.status} ${await res.text()}`);
+        if (!res.ok) throw new Error(await httpFailure(res, "checkout"));
         return res.json();
       }
       // Both take an optional signal for the REPL's sake: they are awaited while the
@@ -292,7 +398,14 @@ var init_client = __esm({
           throw new Error(body.message ?? "Too many searches \u2014 wait a moment and try again.");
         }
         if (!res.ok) {
-          const body = await res.json().catch(() => ({}));
+          const peeked = await peek(res);
+          const block = detectEdgeBlock(res.status, res.headers, peeked.body);
+          if (block) {
+            throw new Error(
+              `The search was rejected by a security filter in front of the gateway (${edgeBlockSummary(block)}); the query reads as an attack payload to it. Rephrase it without the literal payload, or use web_fetch on a URL you know.`
+            );
+          }
+          const body = await peeked.res.json().catch(() => ({}));
           throw new Error(body.message ?? `web search failed: ${res.status}`);
         }
         const data = await res.json();
@@ -306,19 +419,70 @@ var init_client = __esm({
       // wall, and the reward arrives as a signed postback from the network to the
       // gateway. Nothing comes back to the CLI; a rising balance is the only signal,
       // which is why both callers poll `wallet()`.
-      /** Non-streaming chat. Kept for scripted/one-shot paths; the REPL streams. */
-      async chat(messages, model, tools, signal) {
-        const res = await fetch(`${this.config.gatewayUrl}/v1/chat/completions`, {
+      /** One POST to the chat route, in whichever transport is currently in use. */
+      sendChat(payload, encoded, signal) {
+        const json = JSON.stringify(payload);
+        return fetch(`${this.config.gatewayUrl}/v1/chat/completions`, {
           method: "POST",
-          headers: this.headers(),
-          body: JSON.stringify({ model, messages, stream: false, ...tools ? { tools } : {} }),
+          headers: encoded ? { ...this.headers(), "Content-Type": CHAT_ENCODED_CONTENT_TYPE } : this.headers(),
+          body: encoded ? encodeChatBody(json) : json,
           signal
         });
+      }
+      /**
+       * POST a chat request, and get past the edge if the edge 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
+       * anything else somebody points at `CLIXAD_GATEWAY_URL` — and a gateway that
+       * has never heard of the encoded form must keep working. The compressed body
+       * is a workaround for one specific failure, so it engages only once that
+       * failure has actually happened.
+       *
+       * 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.
+       *
+       * Three 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).
+       */
+      async postChat(payload, signal) {
+        const already = this.chatTransport === "encoded";
+        const first = await this.sendChat(payload, already, signal);
+        if (first.status !== 403) return first;
+        const { block, res } = await triage(first);
+        if (!block) return res;
+        if (already) throw new EdgeBlockedError(block, "retried");
+        const retry = await this.sendChat(payload, true, signal);
+        if (retry.status === 415) throw new EdgeBlockedError(block, "unsupported");
+        if (retry.status === 403) {
+          const second = await triage(retry);
+          if (second.block) throw new EdgeBlockedError(second.block, "retried");
+          return second.res;
+        }
+        this.chatTransport = "encoded";
+        this.onNotice?.(
+          `  A security filter in front of the gateway blocked that request (${edgeBlockSummary(block)}).
+  Resent with a compressed body, which got through. Nothing was lost, and the
+  rest of this session will use the same encoding.`
+        );
+        return retry;
+      }
+      /** Non-streaming chat. Kept for scripted/one-shot paths; the REPL streams. */
+      async chat(messages, model, tools, signal) {
+        const res = await this.postChat(
+          { model, messages, stream: false, ...tools ? { tools } : {} },
+          signal
+        );
         if (res.status === 401) throw await authFailure(res, "chat");
         if (res.status === 402) {
           throw paywallError(await res.json());
         }
-        if (!res.ok) throw new Error(`chat failed: ${res.status} ${await res.text()}`);
+        if (!res.ok) throw new Error(await httpFailure(res, "chat"));
         const data = await res.json();
         const choice = data.choices[0];
         if (!choice) throw new Error("chat: no choices in response");
@@ -336,17 +500,15 @@ var init_client = __esm({
        * the agent loop can stream *and* use tools in the same request.
        */
       async chatStream(messages, model, opts = {}) {
-        const res = await fetch(`${this.config.gatewayUrl}/v1/chat/completions`, {
-          method: "POST",
-          headers: this.headers(),
-          body: JSON.stringify({ model, messages, stream: true, ...opts.tools ? { tools: opts.tools } : {} }),
-          signal: opts.signal
-        });
+        const res = await this.postChat(
+          { model, messages, stream: true, ...opts.tools ? { tools: opts.tools } : {} },
+          opts.signal
+        );
         if (res.status === 401) throw await authFailure(res, "chat");
         if (res.status === 402) {
           throw paywallError(await res.json());
         }
-        if (!res.ok || !res.body) throw new Error(`chat failed: ${res.status} ${await res.text()}`);
+        if (!res.ok || !res.body) throw new Error(await httpFailure(res, "chat"));
         let content = "";
         let finishReason = "stop";
         let creditsCharged = 0;
@@ -4279,6 +4441,13 @@ function headRows(text, cols, max) {
   }
   return kept.join("\n");
 }
+function errorNotice(message, rows = ERROR_NOTICE_ROWS) {
+  const clean = message.replace(/\u001b\][^\u0007]*(?:\u0007|\u001b\\)?/g, " ").replace(/\u001b\[[0-9;?]*[ -\/]*[@-~]/g, " ").replace(/[\u0000-\u0009\u000b-\u001f\u007f-\u009f]/g, " ");
+  const lines = clean.split("\n");
+  const kept = lines.slice(0, rows).map((l) => l.length > ERROR_NOTICE_COLS ? `${l.slice(0, ERROR_NOTICE_COLS - 1)}\u2026` : l);
+  if (lines.length > rows) kept.push(`  \u2026 +${lines.length - rows} more lines`);
+  return kept.join("\n");
+}
 function entryHeight(entry, cols) {
   const margin = entry.kind === "banner" ? 0 : 1;
   switch (entry.kind) {
@@ -4325,7 +4494,7 @@ function EntryView({ entry }) {
       ) });
   }
 }
-var MANGO3, MANGO_BRIGHT, SLATE, MODE_STYLE;
+var MANGO3, MANGO_BRIGHT, SLATE, MODE_STYLE, ERROR_NOTICE_ROWS, ERROR_NOTICE_COLS;
 var init_views = __esm({
   "src/tui/views.tsx"() {
     "use strict";
@@ -4339,6 +4508,8 @@ var init_views = __esm({
       acceptEdits: { color: "#7ee787", glyph: "\u23F5\u23F5" },
       plan: { color: "#79c0ff", glyph: "\u23F8" }
     };
+    ERROR_NOTICE_ROWS = 12;
+    ERROR_NOTICE_COLS = 200;
   }
 });
 
@@ -4473,6 +4644,7 @@ function App({ client, config, wallet, session, initialTask }) {
   }, []);
   useEffect(() => dropDelta, [dropDelta]);
   useEffect(() => {
+    client.onNotice = (text2) => push({ kind: "notice", tone: "warn", text: text2 });
     const files = contextRef.current.files;
     if (files.length) push({ kind: "notice", text: `  context: ${files.join(", ")}` });
     if (session?.messages.length) {
@@ -4760,7 +4932,7 @@ ${NO_SEARCH_INSTRUCTION}`),
         } else if (err instanceof AuthError) {
           push({ kind: "notice", tone: "error", text: NOT_SIGNED_IN });
         } else {
-          push({ kind: "notice", tone: "error", text: `  error: ${err.message}` });
+          push({ kind: "notice", tone: "error", text: `  error: ${errorNotice(err.message)}` });
         }
       } finally {
         abortRef.current = null;
@@ -4801,7 +4973,7 @@ ${NO_SEARCH_INSTRUCTION}`),
       } catch (err) {
         if (ac.signal.aborted) push({ kind: "notice", tone: "warn", text: "  (stopped)" });
         else if (err instanceof AuthError) push({ kind: "notice", tone: "error", text: NOT_SIGNED_IN });
-        else push({ kind: "notice", tone: "error", text: `  ${err.message}` });
+        else push({ kind: "notice", tone: "error", text: `  ${errorNotice(err.message)}` });
       } finally {
         busyAbortRef.current = null;
         setBusyLabel(WORKING);

package/package.json

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