@bli-cockpit/cli 0.2.40 → 0.2.42

package/dist/upload.js

@@ -7,7 +7,8 @@ import { buildLocalAmbientEnvelope, LocalUploadBlockedError, } from "./upload-en
 import { applyRawEvidenceUploadOutcomes, hasRetryableEvidenceGap, logEvidenceBackoffBypassed, logEvidenceHeldByBackoff, logPermanentlyRejectedEvidence, partitionHeldEvidenceFiles, permanentEvidenceFailureReason, persistDeliveryAttempts, retrySourcesForFailedSync, retryableEvidenceGapReason, summarizeRawEvidenceDelivery, } from "./upload-evidence-delivery.js";
 import { reportAgentImageArtifacts } from "./upload-agent-artifacts.js";
 import { describeError } from "./health-detail.js";
-import { isNonEmptyString, readResponseJson, responseErrorMessage, } from "./upload-http.js";
+import { isNonEmptyString, readResponseJson, serverFailureDetail, } from "./upload-http.js";
+import { SyncDeliveryError, classifySyncFailure, } from "./upload-failure-reason.js";
 export { LocalUploadBlockedError, buildLocalAmbientEnvelope, } from "./upload-envelope.js";
 export { partitionHeldEvidenceFiles } from "./upload-evidence-delivery.js";
 export { reportAgentImageArtifacts } from "./upload-agent-artifacts.js";
@@ -99,6 +100,17 @@ export async function syncLocalAmbientEnvelope(options = {}) {
             uploadOutcomes,
             attemptedAt,
         });
+        // The success branch logs too. A line that only fires on failure cannot
+        // answer "did anything land at all today?", which is the question that
+        // would have caught BLI-2528 in a week instead of 57 days.
+        console.error("[cockpit-sync] ingest accepted the envelope", JSON.stringify({
+            reason: "ingest_accepted",
+            http_status: response.status,
+            event_count: built.event_count,
+            raw_evidence_file_count: built.raw_evidence_upload_files.length,
+            uploaded_chunk_count: uploadedChunkCount,
+            failed_object_count: uploadOutcomes.filter((outcome) => outcome.upload_state === "upload_failed").length,
+        }));
         return {
             status: "uploaded",
             dashboard_url: built.dashboard_url,
@@ -113,12 +125,26 @@ export async function syncLocalAmbientEnvelope(options = {}) {
         };
     }
     catch (error) {
-        const failureReason = error instanceof Error ? error.message : String(error);
+        // The spool row used to store `error.message` verbatim, so every distinct
+        // server sentence became its own "reason" and nothing could count how many
+        // machines were failing the same way (BLI-3483). It now stores a label from
+        // a closed set plus a bounded, redacted cause.
+        const classified = classifySyncFailure(error);
         // A committed content-addressed object may be shared by concurrent syncs.
         // Never delete it from this error path: an ingest retry can reuse it, while
         // client-side cleanup cannot prove exclusive ownership without racing a
         // second sync that is about to index the same object.
-        const spooledFailureReason = failureReason;
+        const spooledFailureReason = classified.failure_reason;
+        console.error("[cockpit-sync] sync spooled for retry", JSON.stringify({
+            reason: classified.reason,
+            ...(classified.http_status === null
+                ? {}
+                : { http_status: classified.http_status }),
+            ...(classified.detail ? { detail: classified.detail } : {}),
+            event_count: built.event_count,
+            raw_evidence_file_count: built.raw_evidence_upload_files.length,
+            uploaded_chunk_count: uploadedChunkCount,
+        }));
         const entry = await recordUploadFailure(paths, {
             last_attempt_at: attemptedAt,
             dashboard_url: built.dashboard_url,
@@ -182,17 +208,50 @@ async function buildEnvelopeOrRecordBlocker(paths, options, cursorObjects, attem
  * row counts, which is what the receipt check demands.
  */
 async function postEnvelopeToIngest(options) {
-    const response = await options.fetchImpl(`${options.built.dashboard_url}/api/ambient/ingest`, {
-        method: "POST",
-        headers: {
-            "Authorization": `Bearer ${options.built.device_token}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(options.envelope),
-    });
+    let response;
+    try {
+        response = await options.fetchImpl(`${options.built.dashboard_url}/api/ambient/ingest`, {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${options.built.device_token}`,
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(options.envelope),
+        });
+    }
+    catch (error) {
+        // No status came back at all, so no server-side reason exists to read. The
+        // error's own name and code (`TypeError` / `ENOTFOUND` / `ECONNREFUSED`)
+        // are the whole answer, and they are what separates "this machine is
+        // offline" from "the dashboard refused us" — two words that used to be the
+        // same spool row.
+        const described = describeError(error);
+        console.error("[cockpit-sync] ingest request failed before a status came back", JSON.stringify({ reason: "ingest_transport_error", ...described }));
+        throw new SyncDeliveryError("ingest_transport_error", {
+            detail: [
+                described.error_name,
+                described.error_code,
+                described.cause_code ?? described.cause_name,
+                described.error_detail,
+            ]
+                .filter(Boolean)
+                .join(" "),
+            cause: error,
+        });
+    }
     const responseBody = await readResponseJson(response);
     if (!response.ok) {
-        throw new Error(responseErrorMessage(responseBody, `Ambient ingest failed with HTTP ${response.status}`));
+        const serverReason = serverFailureDetail(responseBody);
+        console.error("[cockpit-sync] ingest refused the envelope", JSON.stringify({
+            reason: "ingest_rejected",
+            http_status: response.status,
+            server_reason: serverReason ?? "none",
+            event_count: options.envelope.events.length,
+        }));
+        throw new SyncDeliveryError("ingest_rejected", {
+            httpStatus: response.status,
+            detail: `http ${response.status}; server reason ${serverReason ?? "none"}`,
+        });
     }
     assertAmbientIngestReceipt(response, responseBody, options.envelope);
     return response;
@@ -275,11 +334,26 @@ async function recordIngestedSyncOutcome(options) {
  *
  * Anything short of a 202 whose counts match the envelope's own totals is
  * treated as no receipt at all — a proxy's 200, a truncated body, or a
- * dashboard that accepted fewer rows than were sent all land here.
+ * dashboard that accepted fewer rows than were sent all land here. They used to
+ * land here under the SAME sentence, which is the BLI-3483 complaint: a
+ * network appliance answering on the dashboard's behalf and a dashboard that
+ * genuinely persisted three of four rows are opposite repairs. They are now two
+ * reasons, and the second one names the field that disagreed and by how much.
  */
 function assertAmbientIngestReceipt(response, value, envelope) {
     if (response.status !== 202 || !value || typeof value !== "object") {
-        throw new Error("Ambient ingest returned an invalid durable receipt.");
+        const detail = response.status !== 202
+            ? `http ${response.status}; the ingest route answers 202, so something in front of it replied`
+            : "202 with a body that is not an object";
+        console.error("[cockpit-sync] ingest answered without a durable receipt", JSON.stringify({
+            reason: "ingest_receipt_not_202",
+            http_status: response.status,
+            body_is_object: Boolean(value) && typeof value === "object",
+        }));
+        throw new SyncDeliveryError("ingest_receipt_not_202", {
+            httpStatus: response.status,
+            detail,
+        });
     }
     const record = value;
     const ingest = record["ingest"] && typeof record["ingest"] === "object"
@@ -288,12 +362,39 @@ function assertAmbientIngestReceipt(response, value, envelope) {
     const expectedFactCount = envelope.events.length;
     const expectedRiskFlagCount = envelope.events.reduce((total, event) => total + event.risk_flags.length, 0);
     const expectedEvidenceRefCount = envelope.events.reduce((total, event) => total + event.raw_evidence_pointers.length, 0);
-    if (record["ok"] !== true ||
-        !ingest ||
-        !isNonEmptyString(ingest["work_session_id"]) ||
-        ingest["fact_count"] !== expectedFactCount ||
-        ingest["risk_flag_count"] !== expectedRiskFlagCount ||
-        ingest["evidence_ref_count"] !== expectedEvidenceRefCount) {
-        throw new Error("Ambient ingest returned an incomplete durable receipt.");
+    const mismatches = [];
+    if (record["ok"] !== true)
+        mismatches.push("ok not true");
+    if (!ingest)
+        mismatches.push("no ingest block");
+    if (ingest && !isNonEmptyString(ingest["work_session_id"])) {
+        mismatches.push("blank work_session_id");
+    }
+    if (ingest) {
+        mismatches.push(...countMismatch("fact_count", ingest["fact_count"], expectedFactCount), ...countMismatch("risk_flag_count", ingest["risk_flag_count"], expectedRiskFlagCount), ...countMismatch("evidence_ref_count", ingest["evidence_ref_count"], expectedEvidenceRefCount));
     }
+    if (mismatches.length === 0)
+        return;
+    console.error("[cockpit-sync] ingest receipt does not match what was submitted", JSON.stringify({
+        reason: "ingest_receipt_incomplete",
+        http_status: response.status,
+        mismatch_count: mismatches.length,
+        mismatches,
+    }));
+    throw new SyncDeliveryError("ingest_receipt_incomplete", {
+        httpStatus: response.status,
+        detail: mismatches.join("; "),
+    });
+}
+/**
+ * `submitted 4, receipt 3` — the sentence that tells partial persistence from a
+ * receipt that never carried the field at all. Counts are numbers this
+ * collector computed and numbers the server echoed; neither is content.
+ */
+function countMismatch(field, received, expected) {
+    if (received === expected)
+        return [];
+    return [
+        `${field} submitted ${expected}, receipt ${typeof received === "number" ? received : "absent"}`,
+    ];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.40",
+  "version": "0.2.42",
   "private": false,
   "type": "module",
   "bin": {