@bli-cockpit/cli 0.2.253 → 0.2.255

package/dist/commands/memory-install-codex.js

@@ -90,7 +90,7 @@ async function applyCodexMcpTable(options) {
     if (tableMatches(raw, options.config)) {
         return { target: "codex_mcp", status: "already", reason: "already_current", path: file };
     }
-    const next = upsertTomlTable(raw, MEMORY_TOML_PATH, renderMemoryTable(options.config));
+    const next = upsertTomlTable(raw, MEMORY_TOML_PATH, renderMemoryTable(options.config), "memory-install");
     if (options.dryRun) {
         return { target: "codex_mcp", status: "would_install", reason: "dry_run", path: file };
     }

package/dist/commands/memory-install-toml.js

@@ -58,6 +58,40 @@ export function readTomlTable(text, tablePath) {
         // caller reports a mismatch instead of pretending the field matched.
         out[key] = parseTomlValue(trimmed.slice(equals + 1).trim());
     }
+    // A sub-table spelling of a key we write inline (`[<path>.env]`) is the same
+    // value; the inline key wins when both exist, matching what the writer leaves.
+    for (const key of FOLDED_SUBTABLE_KEYS) {
+        if (key in out)
+            continue;
+        const folded = readFoldedSubtable(text, [...tablePath, key]);
+        if (folded)
+            out[key] = folded;
+    }
+    return out;
+}
+/**
+ * Sub-tables of our table that the renderer writes inline. Only these are
+ * absorbed; deeper or unrelated sub-tables (`.tools.x`) are never ours.
+ */
+const FOLDED_SUBTABLE_KEYS = ["env"];
+function readFoldedSubtable(text, path) {
+    const span = findTomlTableSpan(text, path);
+    if (!span)
+        return null;
+    const out = {};
+    for (const line of text.split("\n").slice(span.start_line + 1, span.end_line)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#"))
+            continue;
+        const equals = trimmed.indexOf("=");
+        if (equals <= 0)
+            continue;
+        const key = unquoteKey(trimmed.slice(0, equals).trim());
+        const value = parseTomlValue(trimmed.slice(equals + 1).trim());
+        if (!key || typeof value !== "string")
+            return null;
+        out[key] = value;
+    }
     return out;
 }
 /**
@@ -65,8 +99,19 @@ export function readTomlTable(text, tablePath) {
  * absent. Everything outside the span is untouched, including trailing
  * whitespace and comments.
  */
-export function upsertTomlTable(text, tablePath, renderedTable) {
+export function upsertTomlTable(text, tablePath, renderedTable, logTag) {
     const block = renderedTable.replace(/\n+$/u, "");
+    // Writing `env` inline while `[<path>.env]` exists is a duplicate key, which
+    // Codex refuses to load. Drop the sub-table; the inline key carries the value.
+    for (const key of FOLDED_SUBTABLE_KEYS) {
+        if (!new RegExp(`^${key}\\s*=`, "mu").test(block))
+            continue;
+        const sub = findTomlTableSpan(text, [...tablePath, key]);
+        if (!sub)
+            continue;
+        text = removeTomlTable(text, [...tablePath, key]);
+        console.error(`[${logTag ?? "toml-table"}] env_subtable_folded ${JSON.stringify({ key, lines: sub.end_line - sub.start_line })}`);
+    }
     const span = findTomlTableSpan(text, tablePath);
     if (!span) {
         if (!text.trim())

package/dist/commands/public-root.js

@@ -21,7 +21,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.253");
+    writeLine(io?.stdout ?? process.stdout, "0.2.255");
     return 0;
   }
 

package/dist/commands/tower-mcp-codex.js

@@ -23,7 +23,7 @@ export async function installCodexTowerIntegration(options) {
     if (tableMatches(raw, options.config)) {
         return { target: "tower_codex_mcp", status: "already", reason: "already_current", path: file };
     }
-    const next = upsertTomlTable(raw, TOWER_TOML_PATH, renderTowerTable(options.config));
+    const next = upsertTomlTable(raw, TOWER_TOML_PATH, renderTowerTable(options.config), "tower-mcp");
     if (options.dryRun) {
         return { target: "tower_codex_mcp", status: "would_install", reason: "dry_run", path: file };
     }

package/dist/evidence-upload-deadline.js

@@ -8,6 +8,28 @@
  * the timer is ref'd, and the race rejects even when an injected or broken
  * fetch ignores the abort, so the caller always gets a named failure.
  */
+/**
+ * One rule for how long a request carrying a body may take (BLI-22801).
+ *
+ * A fixed deadline is wrong for any body whose send time scales with its size:
+ * from Vietnam the path to our US hosts moves about 40 KB/s, so a 1.5 MB gzip
+ * chunk needs ~40 s and a 2 MB one over a minute, and a flat 60 s deadline
+ * timed out every attempt. The deadline is a floor budget (connect, TLS, the
+ * server's own work) plus the time the body needs at a floor throughput of
+ * 8 KiB/s, five times slower than the measured link, capped at 10 minutes.
+ * A truly stalled request still aborts, at that deadline at the latest.
+ *
+ * Chosen over a stalled-progress abort: Node's fetch exposes no upload byte
+ * progress without a streamed duplex body, which an injected fetch and the
+ * signed-URL PUT do not reliably support. A size-scaled total is deterministic.
+ */
+export const UPLOAD_DEADLINE_BASE_MS = 30_000;
+export const UPLOAD_DEADLINE_FLOOR_BYTES_PER_S = 8_192;
+export const UPLOAD_DEADLINE_MAX_MS = 600_000;
+export function uploadDeadlineMs(bodyBytes) {
+    const sendMs = Math.ceil(Math.max(0, bodyBytes) / UPLOAD_DEADLINE_FLOOR_BYTES_PER_S) * 1000;
+    return Math.min(UPLOAD_DEADLINE_MAX_MS, UPLOAD_DEADLINE_BASE_MS + sendMs);
+}
 export const UPLOAD_DEADLINE_ERROR_NAME = "EvidenceUploadDeadlineError";
 export function isUploadDeadlineError(error) {
     return error instanceof Error && error.name === UPLOAD_DEADLINE_ERROR_NAME;

package/dist/evidence-upload-direct.js

@@ -1,8 +1,6 @@
 import { encodeEvidenceBytes } from "@bli-cockpit/telemetry-core/evidence-storage-encoding";
-import { fetchWithDeadline, isUploadDeadlineError } from "./evidence-upload-deadline.js";
+import { fetchWithDeadline, isUploadDeadlineError, uploadDeadlineMs } from "./evidence-upload-deadline.js";
 import { noteSyncProgress } from "./sync-lock.js";
-/** The signed capability is the only credential sent to Storage. Never log it,
- * its query string, provider bodies, or thrown errors that might contain it. */
 export async function putSignedChunk(options, signedUrl, bytes, uploadId, index) {
     // Identical manifest + gzip framing to the server chunk route staging write.
     const encoded = encodeEvidenceBytes(bytes);
@@ -10,36 +8,49 @@ export async function putSignedChunk(options, signedUrl, bytes, uploadId, index)
         upload_id: uploadId, chunk_index: index, chunk_encoding: "gzip",
         bytes_before: bytes.length, bytes_after: encoded.length,
     }));
+    const deadlineMs = uploadDeadlineMs(encoded.length);
+    let deadlineHit = false;
     const attempts = options.maxAttemptsPerRequest ?? 3;
     for (let attempt = 1; attempt <= attempts; attempt++) {
         let status = 0;
+        const startedAt = Date.now();
         try {
             const response = await fetchWithDeadline(options.fetchImpl, signedUrl, {
                 method: "PUT", headers: { "Content-Type": "application/octet-stream", "x-upsert": "false" },
                 body: new Uint8Array(encoded), redirect: "error",
-            }, 60_000);
+            }, deadlineMs);
             status = response.status;
             await response.body?.cancel();
             if (response.ok) {
                 noteSyncProgress();
-                log("signed_chunk_uploaded", uploadId, index, attempt, status);
-                return true;
+                const elapsedMs = Date.now() - startedAt;
+                log("signed_chunk_uploaded", uploadId, index, attempt, status, {
+                    bytes: encoded.length, elapsed_ms: elapsedMs,
+                    bytes_per_s: Math.round(encoded.length / Math.max(elapsedMs, 1) * 1000),
+                });
+                return "uploaded";
             }
             log("signed_upload_refused", uploadId, index, attempt, status);
             if (status < 500 && status !== 429)
-                return false;
+                return "refused";
         }
         catch (error) {
-            log(isUploadDeadlineError(error) ? "signed_upload_deadline_exceeded" : "signed_upload_network_failure", uploadId, index, attempt, status);
+            if (isUploadDeadlineError(error)) {
+                deadlineHit = true;
+                log("signed_upload_deadline_exceeded", uploadId, index, attempt, status, { bytes: encoded.length, deadline_ms: deadlineMs });
+            }
+            else {
+                log("signed_upload_network_failure", uploadId, index, attempt, status);
+            }
         }
         if (attempt < attempts)
             await (options.sleep ?? sleep)(250 * attempt);
     }
-    return false;
+    return deadlineHit ? "deadline" : "refused";
 }
-function log(reason, uploadId, index, attempt, status) {
+function log(reason, uploadId, index, attempt, status, extra = {}) {
     console.error("[evidence-upload] direct chunk", JSON.stringify({
-        reason, upload_id: uploadId, chunk_index: index, attempt, http_status: status,
+        reason, upload_id: uploadId, chunk_index: index, attempt, http_status: status, ...extra,
     }));
 }
 function sleep(ms) { return new Promise(resolve => setTimeout(resolve, ms)); }

package/dist/evidence-upload-object.js

@@ -50,7 +50,17 @@ async function uploadObjectChunks(options, entry, disposition, chunkSizeBytes, o
             continue;
         const chunk = entry.bytes.subarray(index * chunkSizeBytes, Math.min((index + 1) * chunkSizeBytes, entry.bytes.byteLength));
         const offer = disposition.signed_uploads?.find(upload => upload.chunk_index === index);
-        if (offer && await putSignedChunk(options, offer.signed_url, chunk, disposition.upload_id, index)) {
+        const direct = offer
+            ? await putSignedChunk(options, offer.signed_url, chunk, disposition.upload_id, index)
+            : "refused";
+        if (direct === "deadline") {
+            // BLI-22801: the chunk route would push the same bytes over the same slow link.
+            console.error("[evidence-upload] chunk route skipped", JSON.stringify({
+                reason: "signed_upload_deadline_no_fallback", upload_id: disposition.upload_id, chunk_index: index, chunk_bytes: chunk.length,
+            }));
+            return { ok: false, outcome: failedOutcome(entry.file, `chunk_${index}_failed_upload_deadline`, uploadedChunks) };
+        }
+        if (direct === "uploaded") {
             directChunks.push({ chunk_index: index, byte_size: chunk.length,
                 chunk_hash_sha256: sha256(chunk) });
             uploadedChunks += 1;

package/dist/evidence-upload-transport.js

@@ -1,6 +1,6 @@
 import crypto from "node:crypto";
 import { describeError } from "./health-detail.js";
-import { fetchWithDeadline, isUploadDeadlineError } from "./evidence-upload-deadline.js";
+import { fetchWithDeadline, isUploadDeadlineError, uploadDeadlineMs } from "./evidence-upload-deadline.js";
 import { noteSyncProgress } from "./sync-lock.js";
 /**
  * The `send` stage: one retrying POST to an evidence-upload route, plus the
@@ -11,12 +11,13 @@ import { noteSyncProgress } from "./sync-lock.js";
  */
 const DEFAULT_MAX_ATTEMPTS = 3;
 const RETRY_DELAY_MS = 250;
-const REQUEST_DEADLINE_MS = 120_000;
 export async function requestJson(options, routePath, body) {
     const maxAttempts = options.maxAttemptsPerRequest ?? DEFAULT_MAX_ATTEMPTS;
     const sleep = options.sleep ?? defaultSleep;
     let lastStatus = 0;
     let lastBody = null;
+    const serialized = JSON.stringify(body);
+    const deadlineMs = uploadDeadlineMs(Buffer.byteLength(serialized));
     for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
         try {
             const response = await fetchWithDeadline(options.fetchImpl, `${options.dashboardUrl}${routePath}`, {
@@ -27,8 +28,8 @@ export async function requestJson(options, routePath, body) {
                     ...(routePath.endsWith("/evidence/upload/begin")
                         ? { "x-tower-evidence-direct": "staged-gzip-v1" } : {}),
                 },
-                body: JSON.stringify(body),
-            }, REQUEST_DEADLINE_MS);
+                body: serialized,
+            }, deadlineMs);
             lastStatus = response.status;
             lastBody = await readResponseJson(response);
             if (response.ok || (response.status < 500 && response.status !== 429)) {
@@ -50,6 +51,8 @@ export async function requestJson(options, routePath, body) {
                 route: routePath,
                 attempt,
                 max_attempts: maxAttempts,
+                body_bytes: Buffer.byteLength(serialized),
+                deadline_ms: deadlineMs,
                 ...describeError(error),
             }));
             lastStatus = 0;

package/dist/image-describe-client.js

@@ -11,22 +11,23 @@
  */
 import { ImageDescribeResponseSchema, } from "@bli-cockpit/telemetry-core";
 import { describeError } from "./health-detail.js";
+import { fetchWithDeadline, isUploadDeadlineError, uploadDeadlineMs } from "./evidence-upload-deadline.js";
 import { safeFailureDetail } from "./evidence-upload-transport.js";
 import { noteSyncProgress } from "./sync-lock.js";
-const REQUEST_TIMEOUT_MS = 60_000;
 const MAX_ATTEMPTS = 2;
 const RETRY_DELAY_MS = 500;
 export async function postImageToDescribeDoor(options, request) {
     const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+    const payload = JSON.stringify(request);
+    const deadlineMs = uploadDeadlineMs(Buffer.byteLength(payload));
     let last = { ok: false, reason: "transport_error", httpStatus: 0, permanent: false };
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt += 1) {
         try {
-            const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/images`, {
+            const response = await fetchWithDeadline(options.fetchImpl, `${options.dashboardUrl}/api/ambient/images`, {
                 method: "POST",
                 headers: { Authorization: `Bearer ${options.deviceToken}`, "Content-Type": "application/json" },
-                body: JSON.stringify(request),
-                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
-            });
+                body: payload,
+            }, deadlineMs);
             const body = await readJson(response);
             noteSyncProgress();
             if (response.ok) {
@@ -41,7 +42,7 @@ export async function postImageToDescribeDoor(options, request) {
                 return last;
         }
         catch (error) {
-            console.error("[image-describe] request failed before a status came back", JSON.stringify({ reason: "transport_error", attempt, max_attempts: MAX_ATTEMPTS, sha256_prefix: request.sha256.slice(0, 16), ...describeError(error) }));
+            console.error("[image-describe] request failed before a status came back", JSON.stringify({ reason: isUploadDeadlineError(error) ? "deadline_exceeded" : "transport_error", body_bytes: Buffer.byteLength(payload), deadline_ms: deadlineMs, attempt, max_attempts: MAX_ATTEMPTS, sha256_prefix: request.sha256.slice(0, 16), ...describeError(error) }));
             last = { ok: false, reason: "transport_error", httpStatus: 0, permanent: false };
         }
         if (attempt < MAX_ATTEMPTS)

package/package.json

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