npm - @inerrata-corporation/errata - Versions diffs - 2.0.2-dev.227 → 2.0.2-dev.245 - Mend

@inerrata-corporation/errata 2.0.2-dev.227 → 2.0.2-dev.245

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/errata.mjs +129 -15
package/package.json +1 -1

package/errata.mjs CHANGED Viewed

@@ -21643,6 +21643,7 @@ var init_oauth = __esm({
 // ../../packages/cloud-client/src/client.ts
 import { randomUUID } from "node:crypto";
+import { gzipSync } from "node:zlib";
 function wirePerContext(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return null;
   const out2 = {};
@@ -21840,6 +21841,11 @@ function normalizeSolution(input) {
     validationSource: input.validationSource
   };
 }
+function isIntermediaryRejection(err2) {
+  if (!(err2 instanceof CloudError)) return false;
+  if (err2.status < 400 || err2.status >= 500) return false;
+  return /<!DOCTYPE html|<html/i.test(err2.message);
+}
 function chunkArray(items, size) {
   if (items.length <= size) return items.length ? [[...items]] : [];
   const out2 = [];
@@ -21857,7 +21863,7 @@ function provenanceHeaders(provenance) {
     ...provenance.agentModel ? { "x-inerrata-agent-model": provenance.agentModel } : {}
   };
 }
-var asWireCount, INGEST_NODE_CHUNK, CloudClient, CloudError;
+var asWireCount, INGEST_NODE_CHUNK, COMPRESS_MIN_BYTES, CloudClient, CloudError;
 var init_client = __esm({
   "../../packages/cloud-client/src/client.ts"() {
     "use strict";
@@ -21865,6 +21871,7 @@ var init_client = __esm({
     init_src();
     asWireCount = (n) => typeof n === "number" && Number.isFinite(n) && n >= 0 ? Math.floor(n) : null;
     INGEST_NODE_CHUNK = 8;
+    COMPRESS_MIN_BYTES = 4096;
     CloudClient = class {
       baseUrl;
       apiKey;
@@ -21879,6 +21886,8 @@ var init_client = __esm({
       daemonVersion;
       daemonChannel;
       provenance;
+      /** Cleared for the process once a server proves it cannot inflate (see `json`). */
+      compressRequests;
       constructor(opts) {
         this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
         if (opts.apiKey !== void 0) this.apiKey = opts.apiKey;
@@ -21892,6 +21901,7 @@ var init_client = __esm({
         this.timeoutMs = opts.timeoutMs ?? 15e3;
         this.daemonVersion = opts.daemonVersion;
         this.daemonChannel = opts.daemonChannel;
+        this.compressRequests = opts.compressRequests ?? true;
         this.provenance = opts.provenance ?? {
           clientProduct: "inerrata_cloud_client",
           clientKind: "sdk",
@@ -22029,18 +22039,24 @@ var init_client = __esm({
         const startedAt = Date.now();
         const totalChunks = Math.max(1, Math.ceil(batch.nodes.length / INGEST_NODE_CHUNK)) + Math.ceil(Math.max(0, batch.edges.length - MAX_EDGES_PER_PAYLOAD) / MAX_EDGES_PER_PAYLOAD);
         let chunkIndex = 0;
+        const blocked = [];
         const emit = (nodeIds, accepted) => {
           chunkIndex++;
+          const refused = blocked.splice(0, blocked.length);
+          const refusedSet = new Set(refused);
           opts.onChunk?.({
             chunkIndex,
             totalChunks,
-            nodeIds,
+            // Watermark only what actually landed — a blocked node never reached the
+            // door, and marking it contributed would lose it permanently and silently.
+            nodeIds: refusedSet.size ? nodeIds.filter((id) => !refusedSet.has(id)) : nodeIds,
             accepted,
-            elapsedMs: Date.now() - startedAt
+            elapsedMs: Date.now() - startedAt,
+            ...refused.length ? { blockedNodeIds: refused } : {}
           });
         };
         if (batch.nodes.length <= INGEST_NODE_CHUNK && batch.edges.length <= MAX_EDGES_PER_PAYLOAD) {
-          const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges);
+          const result = await this.ingestWithSplit(batch, batch.nodes, batch.edges, blocked);
           const summary = summarizeIngestResult(result);
           emit(batch.nodes.map((n) => n.id), summary.accepted);
           return { ...summary, result };
@@ -22055,7 +22071,7 @@ var init_client = __esm({
             const shipped = new Set(inChunk);
             pendingEdges = pendingEdges.filter((e) => !shipped.has(e));
           }
-          const r = await this.ingestWithSplit(batch, nodeChunk, inChunk);
+          const r = await this.ingestWithSplit(batch, nodeChunk, inChunk, blocked);
           emit(nodeChunk.map((n) => n.id), summarizeIngestResult(r).accepted);
           merged.nodes.push(...r.nodes);
           merged.edges.push(...r.edges);
@@ -22098,16 +22114,21 @@ var init_client = __esm({
        * a verdict about the payload — splitting it would just re-send a rejected batch
        * N more times — and a 409/413 has its own handling upstream.
        */
-      async ingestWithSplit(batch, nodes, edges) {
+      async ingestWithSplit(batch, nodes, edges, blocked) {
         try {
           return await this.ingestWire(toWirePayload({ ...batch, nodes, edges }, randomUUID()));
         } catch (err2) {
           const status = err2 instanceof CloudError ? err2.status : 0;
           const timedOut = status === 502 || status === 504 || status === 408 || status === 0;
-          if (!timedOut || nodes.length <= 1) throw err2;
+          const refusedAtEdge = blocked !== void 0 && isIntermediaryRejection(err2);
+          if (refusedAtEdge && nodes.length === 1 && nodes[0]) {
+            blocked.push(nodes[0].id);
+            return { runId: randomUUID(), nodes: [], edges: [] };
+          }
+          if (!timedOut && !refusedAtEdge || nodes.length <= 1) throw err2;
           const mid = Math.ceil(nodes.length / 2);
-          const a = await this.ingestWithSplit(batch, nodes.slice(0, mid), edges);
-          const b = await this.ingestWithSplit(batch, nodes.slice(mid), []);
+          const a = await this.ingestWithSplit(batch, nodes.slice(0, mid), edges, blocked);
+          const b = await this.ingestWithSplit(batch, nodes.slice(mid), [], blocked);
           return {
             runId: a.runId,
             nodes: [...a.nodes, ...b.nodes],
@@ -22409,15 +22430,43 @@ var init_client = __esm({
           const token = opts?.bearerToken ?? await this.authToken();
           if (token) headers["authorization"] = `Bearer ${token}`;
         }
+        let payload;
+        if (body2 !== void 0) {
+          const raw2 = JSON.stringify(body2);
+          if (this.compressRequests && Buffer.byteLength(raw2) >= COMPRESS_MIN_BYTES) {
+            payload = gzipSync(Buffer.from(raw2));
+            headers["content-encoding"] = "gzip";
+          } else {
+            payload = raw2;
+          }
+        }
         const ac = new AbortController();
         const tid = setTimeout(() => ac.abort(), this.timeoutMs);
         try {
           const res = await this.fetchFn(url2, {
             method,
             headers,
-            body: body2 === void 0 ? void 0 : JSON.stringify(body2),
+            body: payload,
             signal: ac.signal
           });
+          if (res.status === 400 && headers["content-encoding"] === "gzip") {
+            delete headers["content-encoding"];
+            const retry = await this.fetchFn(url2, {
+              method,
+              headers,
+              body: JSON.stringify(body2),
+              signal: ac.signal
+            });
+            if (!retry.ok) {
+              const text = await retry.text();
+              throw new CloudError(
+                `${method} ${path2} failed: HTTP ${retry.status} ${text.slice(0, 200)}`,
+                retry.status
+              );
+            }
+            this.compressRequests = false;
+            return await retry.json();
+          }
           if (!res.ok) {
             const text = await res.text();
             throw new CloudError(
@@ -52458,7 +52507,7 @@ function startLoopLagMonitor(thresholdMs = 1e3) {
 }
 // src/engine.ts
-var DAEMON_VERSION = true ? "2.0.2-dev.227" : "2.0.0-alpha.0";
+var DAEMON_VERSION = true ? "2.0.2-dev.245" : "2.0.0-alpha.0";
 var IGNORED_PATH = /[\\/](?:\.git|node_modules|\.errata|\.claude|\.codex|\.cursor|\.turbo|\.next|dist|coverage|test-results|playwright-report|__pycache__)(?:[\\/]|$)/;
 var IGNORED_NOISE = /castalia\.db|eventlog\.sqlite|turn-cursors/;
 var GIT_OP_MUTE_MS = 4e3;
@@ -54729,6 +54778,39 @@ init_config();
 // src/update.ts
 import { spawn as spawn2 } from "node:child_process";
 var PACKAGE_NAME = "@inerrata-corporation/errata";
+function parse3(v) {
+  const m = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z][0-9A-Za-z.-]*))?/.exec(v.trim());
+  if (!m) return null;
+  return {
+    base: [Number(m[1]), Number(m[2]), Number(m[3])],
+    pre: m[4] === void 0 ? null : m[4].split(/[.-]/).map((p) => /^\d+$/.test(p) ? Number(p) : p)
+  };
+}
+function compareVersions(a, b) {
+  const pa = parse3(a);
+  const pb = parse3(b);
+  if (!pa || !pb) return 0;
+  const [aMaj, aMin, aPatch] = pa.base;
+  const [bMaj, bMin, bPatch] = pb.base;
+  if (aMaj !== bMaj) return aMaj - bMaj;
+  if (aMin !== bMin) return aMin - bMin;
+  if (aPatch !== bPatch) return aPatch - bPatch;
+  if (pa.pre === null && pb.pre === null) return 0;
+  if (pa.pre === null) return 1;
+  if (pb.pre === null) return -1;
+  for (let i2 = 0; i2 < Math.max(pa.pre.length, pb.pre.length); i2++) {
+    const x = pa.pre[i2];
+    const y = pb.pre[i2];
+    if (x === void 0) return -1;
+    if (y === void 0) return 1;
+    if (x === y) continue;
+    if (typeof x === "number" && typeof y === "number") return x - y;
+    if (typeof x === "number") return -1;
+    if (typeof y === "number") return 1;
+    return x < y ? -1 : 1;
+  }
+  return 0;
+}
 async function latestPublished(channel, timeoutMs = 4e3) {
   const ctrl = new AbortController();
   const timer = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -54748,10 +54830,14 @@ async function latestPublished(channel, timeoutMs = 4e3) {
 }
 async function checkForUpdate(channel) {
   const latest = await latestPublished(channel);
+  const direction = latest === null ? 0 : compareVersions(latest, DAEMON_VERSION);
   return {
     current: DAEMON_VERSION,
     latest,
-    updateAvailable: latest !== null && latest !== DAEMON_VERSION
+    // `compareVersions` returns 0 for unparseable input, so an unrecognizable tag
+    // is treated as "nothing to do" rather than gambling on a direction.
+    updateAvailable: latest !== null && direction > 0,
+    downgradeAvailable: latest !== null && direction < 0
   };
 }
 var POLL_INTERVAL_MS = {
@@ -55733,6 +55819,11 @@ async function startMultiDaemon(opts = {}) {
                   if (!local) continue;
                   store.updateNode(localId, { attrs: { ...local.attrs, contributedAtSeq: seq } });
                 }
+                if (p.blockedNodeIds?.length) {
+                  console.log(
+                    `[sync\u2192cloud] [${projectName}] context: ${p.blockedNodeIds.length} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry`
+                  );
+                }
                 noteFlushProgress(p.accepted, p.nodeIds.length, `context ${p.chunkIndex}/${p.totalChunks}`);
               }
             });
@@ -55762,9 +55853,18 @@ async function startMultiDaemon(opts = {}) {
         if (instances) {
           if (project) instances.projectId = project.projectId;
           await lane("instances", projectName, async () => {
+            const blocked = /* @__PURE__ */ new Set();
             const res = await client.ingest(instances, {
-              onChunk: (p) => noteFlushProgress(p.accepted, p.nodeIds.length, `instances ${p.chunkIndex}/${p.totalChunks}`)
+              onChunk: (p) => {
+                for (const id of p.blockedNodeIds ?? []) blocked.add(id);
+                noteFlushProgress(p.accepted, p.nodeIds.length, `instances ${p.chunkIndex}/${p.totalChunks}`);
+              }
             });
+            if (blocked.size > 0) {
+              console.log(
+                `[sync\u2192cloud] [${projectName}] instances: ${blocked.size} node(s) refused by an edge/CDN filter on content \u2014 left pending, will retry. First: ${store.getNode([...blocked][0])?.description.slice(0, 120) ?? [...blocked][0]}`
+              );
+            }
             uploaded += res.accepted;
             const seq = store.currentIngestSeq();
             const cloudIdByLocal = new Map(
@@ -55773,6 +55873,7 @@ async function startMultiDaemon(opts = {}) {
             for (const n of instances.nodes) {
               const local = store.getNode(n.id);
               if (!local || !["Problem", "Solution", "RootCause"].includes(local.label)) continue;
+              if (blocked.has(n.id)) continue;
               const cloudNodeId = cloudIdByLocal.get(n.id);
               store.updateNode(n.id, {
                 attrs: {
@@ -57214,9 +57315,11 @@ async function cmdUpdate(args2) {
   const cfg = loadConfig();
   let channel = cfg.updateChannel;
   let checkOnly = false;
+  let allowDowngrade = false;
   for (let i2 = 0; i2 < args2.length; i2++) {
     const a = args2[i2];
     if (a === "--check") checkOnly = true;
+    else if (a === "--allow-downgrade") allowDowngrade = true;
     else if (a === "--channel") {
       const v = args2[++i2];
       if (v === "dev" || v === "latest") channel = v;
@@ -57237,8 +57340,19 @@ async function cmdUpdate(args2) {
     return;
   }
   if (!status.updateAvailable) {
-    console.log(`errata is up to date \u2014 ${status.current} (channel: ${channel})`);
-    return;
+    if (status.downgradeAvailable) {
+      console.log(
+        `channel '${channel}' points at ${status.latest}, which is OLDER than the running ${status.current}.`
+      );
+      console.log(`  not installing \u2014 a downgrade past a store migration cannot open its own graph.`);
+      console.log(`  if this is a deliberate rollback: errata update --allow-downgrade`);
+      if (!allowDowngrade) return;
+      console.log(`
+--allow-downgrade given; proceeding.`);
+    } else {
+      console.log(`errata is up to date \u2014 ${status.current} (channel: ${channel})`);
+      return;
+    }
   }
   console.log(`update available: ${status.current} \u2192 ${status.latest} (channel: ${channel})`);
   if (checkOnly) {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@inerrata-corporation/errata",
-  "version": "2.0.2-dev.227",
+  "version": "2.0.2-dev.245",
   "description": "errata - local-first observation engine for AI coding agents",
   "type": "module",
   "bin": {