@flowapt/flowiq-cli 0.12.0 → 0.12.1

package/README.md

@@ -2303,6 +2303,20 @@ flowiq woo get <org> products --all --fields id,name,permalink,status   # past t
 - Not a CLI fix: #186 (Shopify store analytics need the `read_reports` scope
   on the FlowIQ app).
 
+### 0.12.1: dropped connections and `insights status <org>`
+
+- **A read survives a dropped connection.** A bare `Request failed: fetch failed`
+  (the connection dropped, often when several commands run at once) is retried
+  twice with a short backoff on every GET. A write (POST / PUT / DELETE) is never
+  repeated blind: it may have reached the server, so the error says to check the
+  result before retrying. Measured on 2 Oct 2026: 30 of 57 month-by-month
+  `shopify get --all` pulls failed this way five at a time on 0.11.0; twelve run
+  six at a time on 0.12.1 all came back (6,538 orders, `flowiq gaps` #198).
+- **`flowiq insights status <org>` no longer times out.** The server used to
+  count 30 days of messages for every org and keep one; it now counts only the
+  org asked for (0.2 s), and the all-orgs listing reads each org on its own index
+  (about 1 s for 60 orgs). Server-side, so it works on any CLI version (#130).
+
 ### Guide — `flowiq guide`
 
 Read the bundled docs in the terminal — no digging through node_modules.

package/TEAM-GUIDE.md

@@ -459,6 +459,8 @@ Three things worth knowing:
 | "Organization has no active_whatsapp_agent" | Target the agent directly: `--agent <id>` (ids from `flowiq agent list <org_id>`) |
 | Login browser page says the code expired | Codes live 10 minutes — just re-run `flowiq auth login` |
 | Pushed the wrong thing | Everything is pull→push, so re-pull an older copy if you have one, or check with Matt — server logs record every push with who/what/when |
+| `could not reach the API after 3 tries` | The connection dropped (0.12.1 already retried the read twice). Run it again, and run fewer commands at once |
+| `lost its connection … may still have finished the write` | A write is never retried for you: check the result (`list` / `status` / `pull`, or `flowiq audit`) before running it again |
 
 ChatCart rollout: Pick n Pay uses retailer `pnp` and the private connection link.
 Enable its gateway before adding it to the agent tools. Cart retries use

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowapt/flowiq-cli",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "Command-line tool for FlowIQ staff: round-trip agent prompts, questionnaires, fine-tuning, pin-board tasks, webhooks, templates, agent-updates, chat exports, and live agent testing without ever touching service-role credentials.",
   "type": "module",
   "bin": {

package/src/http-retry.test.mjs

@@ -0,0 +1,48 @@
+// node --test src/http-retry.test.mjs
+import test from "node:test";
+import assert from "node:assert/strict";
+import { fetchWithRetry, isNetworkError } from "./http.js";
+
+const dropped = () => Object.assign(new TypeError("fetch failed"), { cause: { code: "ECONNRESET" } });
+const noSleep = async () => {};
+
+test("isNetworkError: a dropped connection yes, a programming error no", () => {
+  assert.equal(isNetworkError(dropped()), true);
+  assert.equal(isNetworkError(new TypeError("Invalid URL")), false);
+  assert.equal(isNetworkError(new Error("boom")), false);
+});
+
+test("fetchWithRetry: a GET is retried after a dropped connection", async () => {
+  let calls = 0;
+  const fetchImpl = async () => { calls++; if (calls < 3) throw dropped(); return { ok: true }; };
+  const resp = await fetchWithRetry("u", {}, { method: "GET", endpoint: "store-api", fetchImpl, sleep: noSleep });
+  assert.deepEqual(resp, { ok: true });
+  assert.equal(calls, 3);
+});
+
+test("fetchWithRetry: a GET gives up after 3 tries and says it is the network", async () => {
+  let calls = 0;
+  const fetchImpl = async () => { calls++; throw dropped(); };
+  await assert.rejects(
+    fetchWithRetry("u", {}, { method: "GET", endpoint: "store-api", fetchImpl, sleep: noSleep }),
+    (e) => e.code === "ENETWORK" && /after 3 tries/.test(e.message) && /ECONNRESET/.test(e.message)
+  );
+  assert.equal(calls, 3);
+});
+
+test("fetchWithRetry: a write is never repeated and says check before retrying", async () => {
+  let calls = 0;
+  const fetchImpl = async () => { calls++; throw dropped(); };
+  await assert.rejects(
+    fetchWithRetry("u", {}, { method: "POST", endpoint: "prompts", fetchImpl, sleep: noSleep }),
+    (e) => e.code === "ENETWORK" && /may still have finished the write/.test(e.message)
+  );
+  assert.equal(calls, 1);
+});
+
+test("fetchWithRetry: a non-network error is not retried", async () => {
+  let calls = 0;
+  const fetchImpl = async () => { calls++; throw new TypeError("Invalid URL"); };
+  await assert.rejects(fetchWithRetry("u", {}, { method: "GET", fetchImpl, sleep: noSleep }), /Invalid URL/);
+  assert.equal(calls, 1);
+});

package/src/http.js

@@ -118,6 +118,45 @@ export function isVercelChallenge(status, headers, text) {
   return (status === 403 || status === 429) && /Vercel Security Checkpoint|vercel-challenge|_vercel\/challenge/i.test(text || "");
 }
 
+// A dropped connection surfaces from undici as a bare "TypeError: fetch failed"
+// (the real reason sits in err.cause). Several CLI calls in parallel hit it
+// (2 Oct 2026: 30 of 57 month-by-month `shopify get --all` pulls, `flowiq gaps`
+// #198), and every one succeeded when simply re-run. A read is safe to repeat,
+// so GETs retry twice with a short backoff; a write is never repeated blind,
+// because it may have reached the server before the connection dropped.
+const NETWORK_ERROR = /fetch failed|ECONNRESET|ECONNREFUSED|ETIMEDOUT|EAI_AGAIN|ENOTFOUND|EPIPE|UND_ERR_|socket hang up|other side closed/i;
+
+export function isNetworkError(e) {
+  const text = [e?.message, e?.code, e?.cause?.code, e?.cause?.message].filter(Boolean).join(" ");
+  return NETWORK_ERROR.test(text);
+}
+
+export async function fetchWithRetry(url, init, { method = "GET", endpoint = "", fetchImpl = fetch, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), attempts } = {}) {
+  const max = attempts ?? (method === "GET" ? 3 : 1);
+  for (let i = 1; ; i++) {
+    try {
+      return await fetchImpl(url, init);
+    } catch (e) {
+      if (!isNetworkError(e)) throw e;
+      const reason = e?.cause?.code || e?.cause?.message || e?.message || "network error";
+      if (i < max) {
+        await sleep(400 * 2 ** (i - 1) + Math.floor(Math.random() * 250));
+        continue;
+      }
+      const err = new Error(
+        method === "GET"
+          ? `${method} ${endpoint} could not reach the API after ${max} tries (${reason}). ` +
+            `This is the network, not the request: run it again, and run fewer at once.`
+          : `${method} ${endpoint} lost its connection (${reason}). The server may still have finished the write: ` +
+            `check the result (the command's list / status / pull verb, or flowiq audit) before retrying.`
+      );
+      err.code = "ENETWORK";
+      err.cause = e;
+      throw err;
+    }
+  }
+}
+
 async function call(method, endpoint, { query, body } = {}) {
   const cfg = await loadConfig();
   if (!cfg.token) {
@@ -148,7 +187,7 @@ async function call(method, endpoint, { query, body } = {}) {
     init.body = JSON.stringify(body);
   }
 
-  const resp = await fetch(url, init);
+  const resp = await fetchWithRetry(url, init, { method, endpoint });
   noteServerContract(resp);
   const text = await resp.text();
   let parsed, isJson = true;