@bli-cockpit/cli 0.2.254 → 0.2.256

package/dist/commands/toml-duplicate-keys.js

@@ -0,0 +1,192 @@
+/**
+ * Finds the first key a TOML file defines twice (BLI-22766).
+ *
+ * Why this exists: `codex` refuses to start when `~/.codex/config.toml` defines
+ * one key twice — for example `[mcp_servers.bli-memory]` holding an inline
+ * `env = { … }` AND a separate `[mcp_servers.bli-memory.env]` table. It prints
+ * `config.toml:180:25: duplicate key` and does nothing else, so every Codex
+ * worker on that machine dies silently. `cockpit doctor` needs to say so, by
+ * file and line.
+ *
+ * This is NOT a TOML parser, for the same reason `memory-install-toml.ts` is
+ * not one: the public CLI ships no TOML dependency. It models only what makes a
+ * key "defined": table headers, array-of-table headers, `key = value` lines
+ * (dotted keys included) and inline tables. It skips over multi-line strings
+ * and multi-line arrays so their contents are never mistaken for keys. The
+ * tests check its answer against a real TOML parser on the same fixtures.
+ *
+ * What it does NOT catch: syntax errors that are not duplicate keys (a missing
+ * quote, a bad date). Those still break Codex; this check reports only the
+ * class of breakage our own writer could cause.
+ */
+export function findTomlDuplicateKey(text) {
+    const values = new Set();
+    const tables = new Set();
+    const dottedTables = new Set();
+    const arrayTables = new Map();
+    let current = [];
+    let pending = null;
+    const lines = text.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? "";
+        if (pending) {
+            pending = continuePending(line, pending);
+            continue;
+        }
+        const trimmed = stripComment(line).trim();
+        if (!trimmed)
+            continue;
+        if (trimmed.startsWith("[[")) {
+            const raw = trimmed.slice(2, trimmed.lastIndexOf("]]"));
+            const resolved = resolveArrayPrefixes(splitKeyPath(raw), arrayTables, false);
+            const id = encode(resolved);
+            const count = (arrayTables.get(id) ?? 0) + 1;
+            arrayTables.set(id, count);
+            current = [...resolved, `#${count}`];
+            continue;
+        }
+        if (trimmed.startsWith("[")) {
+            const resolved = resolveArrayPrefixes(splitKeyPath(trimmed.slice(1, trimmed.lastIndexOf("]"))), arrayTables, true);
+            const id = encode(resolved);
+            if (tables.has(id) || dottedTables.has(id) || hasValuePrefix(values, resolved)) {
+                return duplicate(index, resolved);
+            }
+            tables.add(id);
+            current = resolved;
+            continue;
+        }
+        const equals = indexOutsideQuotes(trimmed, "=");
+        if (equals <= 0)
+            continue;
+        const full = [...current, ...splitKeyPath(trimmed.slice(0, equals))];
+        const id = encode(full);
+        if (hasValuePrefix(values, full) || tables.has(id) || dottedTables.has(id)) {
+            return duplicate(index, full);
+        }
+        if (hasTableUnder(tables, full))
+            return duplicate(index, full);
+        values.add(id);
+        for (let length = current.length + 1; length < full.length; length += 1) {
+            dottedTables.add(encode(full.slice(0, length)));
+        }
+        pending = openPending(trimmed.slice(equals + 1).trim());
+    }
+    return null;
+}
+function duplicate(index, path) {
+    return { line: index + 1, key: path.filter((part) => !part.startsWith("#")).join(".") };
+}
+function encode(path) {
+    return JSON.stringify(path);
+}
+function hasValuePrefix(values, path) {
+    for (let length = 1; length <= path.length; length += 1) {
+        if (values.has(encode(path.slice(0, length))))
+            return true;
+    }
+    return false;
+}
+function hasTableUnder(tables, path) {
+    const prefix = encode(path).slice(0, -1);
+    for (const table of tables) {
+        if (table.startsWith(`${prefix},`))
+            return true;
+    }
+    return false;
+}
+/** `[a.b]` after `[[a]]` means "b inside the LAST a" — give it that element's path. */
+function resolveArrayPrefixes(path, arrayTables, includeLast) {
+    const resolved = [];
+    path.forEach((part, index) => {
+        resolved.push(part);
+        if (!includeLast && index === path.length - 1)
+            return;
+        const count = arrayTables.get(encode(resolved));
+        if (count !== undefined)
+            resolved.push(`#${count}`);
+    });
+    return resolved;
+}
+/** Decides whether a value continues onto later lines. */
+function openPending(value) {
+    for (const closer of ['"""', "'''"]) {
+        if (value.startsWith(closer)) {
+            return value.indexOf(closer, closer.length) >= 0 ? null : { kind: "string", closer };
+        }
+    }
+    if (value.startsWith("[") || value.startsWith("{")) {
+        const depth = bracketDepth(value, 0);
+        return depth > 0 ? { kind: "brackets", depth } : null;
+    }
+    return null;
+}
+function continuePending(line, pending) {
+    if (pending.kind === "string")
+        return line.includes(pending.closer) ? null : pending;
+    const depth = bracketDepth(line, pending.depth);
+    return depth > 0 ? { kind: "brackets", depth } : null;
+}
+function bracketDepth(raw, start) {
+    let depth = start;
+    let quote = null;
+    for (const character of raw) {
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'")
+            quote = character;
+        else if (character === "#")
+            break;
+        else if (character === "[" || character === "{")
+            depth += 1;
+        else if (character === "]" || character === "}")
+            depth -= 1;
+    }
+    return depth;
+}
+function indexOutsideQuotes(raw, target) {
+    let quote = null;
+    for (let index = 0; index < raw.length; index += 1) {
+        const character = raw[index];
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === '"' || character === "'")
+            quote = character;
+        else if (character === target)
+            return index;
+    }
+    return -1;
+}
+function stripComment(raw) {
+    const index = indexOutsideQuotes(raw, "#");
+    return index < 0 ? raw : raw.slice(0, index);
+}
+function splitKeyPath(raw) {
+    const parts = [];
+    let current = "";
+    let quote = null;
+    for (const character of raw) {
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            continue;
+        }
+        if (character === '"' || character === "'")
+            quote = character;
+        else if (character === ".") {
+            parts.push(current.trim());
+            current = "";
+        }
+        else
+            current += character;
+    }
+    parts.push(current.trim());
+    return parts;
+}

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

@@ -12,46 +12,25 @@
  */
 import path from "node:path";
 import { TOWER_MCP_SERVER_ID } from "./tower-mcp-contract.js";
-import { findTomlTableSpan, readTomlTable, renderTomlTable, upsertTomlTable, } from "./memory-install-toml.js";
+import { MEMORY_MCP_SERVER_ID, } from "./memory-install-contract.js";
+import { findTomlTableSpan } from "./memory-install-toml.js";
+import { applyCodexServerTable, codexConfigUnparseable, codexServerTableMatches, } from "./codex-mcp-table.js";
 const TOWER_TOML_PATH = ["mcp_servers", TOWER_MCP_SERVER_ID];
+/** BLI Memory's writer runs first on the same command and repairs its own table. */
+const SIBLING_TOML_PATH = ["mcp_servers", MEMORY_MCP_SERVER_ID];
 export function codexConfigFile(homeDir) {
     return path.join(homeDir, ".codex", "config.toml");
 }
 export async function installCodexTowerIntegration(options) {
-    const file = codexConfigFile(options.homeDir);
-    const raw = (await options.io.readText(file)) ?? "";
-    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), "tower-mcp");
-    if (options.dryRun) {
-        return { target: "tower_codex_mcp", status: "would_install", reason: "dry_run", path: file };
-    }
-    try {
-        await options.io.writeText(file, next);
-    }
-    catch (error) {
-        return {
-            target: "tower_codex_mcp",
-            status: "failed",
-            reason: "write_failed",
-            path: file,
-            detail: error instanceof Error ? error.message : String(error),
-        };
-    }
-    // BLI-2541: parse the table back out of the stored bytes, same discipline
-    // as every other target this installer writes.
-    const stored = await options.io.readText(file);
-    if (stored === null || !tableMatches(stored, options.config)) {
-        return {
-            target: "tower_codex_mcp",
-            status: "failed",
-            reason: "read_back_mismatch",
-            path: file,
-            detail: "the table on disk does not parse back to the entry that was written",
-        };
-    }
-    return { target: "tower_codex_mcp", status: "installed", reason: "wrote_entry", path: file };
+    return applyCodexServerTable({
+        file: codexConfigFile(options.homeDir),
+        target: "tower_codex_mcp",
+        tablePath: TOWER_TOML_PATH,
+        siblingPath: SIBLING_TOML_PATH,
+        config: options.config,
+        dryRun: options.dryRun,
+        io: options.io,
+    });
 }
 export async function inspectCodexTowerIntegration(options) {
     const file = codexConfigFile(options.homeDir);
@@ -59,42 +38,14 @@ export async function inspectCodexTowerIntegration(options) {
     if (raw === null) {
         return { target: "tower_codex_mcp", status: "missing", reason: "file_absent", path: file };
     }
-    if (tableMatches(raw, options.config)) {
+    // BLI-22766: a file Codex cannot load is named first, whatever our table says.
+    const broken = codexConfigUnparseable(raw, file, "tower_codex_mcp");
+    if (broken)
+        return broken;
+    if (codexServerTableMatches(raw, TOWER_TOML_PATH, options.config)) {
         return { target: "tower_codex_mcp", status: "installed", reason: "already_current", path: file };
     }
     return findTomlTableSpan(raw, TOWER_TOML_PATH)
         ? { target: "tower_codex_mcp", status: "mismatch", reason: "entry_differs", path: file }
         : { target: "tower_codex_mcp", status: "missing", reason: "entry_absent", path: file };
-}
-function renderTowerTable(config) {
-    const entries = [
-        ["command", config.mcp_server.command],
-        ["args", config.mcp_server.args],
-    ];
-    if (Object.keys(config.mcp_server.env).length > 0) {
-        entries.push(["env", config.mcp_server.env]);
-    }
-    return renderTomlTable(TOWER_TOML_PATH, entries);
-}
-function tableMatches(raw, config) {
-    const table = readTomlTable(raw, TOWER_TOML_PATH);
-    if (!table)
-        return false;
-    if (table["command"] !== config.mcp_server.command)
-        return false;
-    const args = table["args"];
-    if (!Array.isArray(args))
-        return config.mcp_server.args.length === 0;
-    if (args.length !== config.mcp_server.args.length)
-        return false;
-    if (!args.every((entry, index) => entry === config.mcp_server.args[index]))
-        return false;
-    const env = table["env"];
-    for (const [key, value] of Object.entries(config.mcp_server.env)) {
-        if (!env || Array.isArray(env) || typeof env === "string")
-            return false;
-        if (env[key] !== value)
-            return false;
-    }
-    return true;
 }

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.254",
+  "version": "0.2.256",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.75",
-    "@bli-cockpit/mcp": "0.1.156",
-    "@bli-cockpit/telemetry-core": "0.1.82"
+    "@bli-cockpit/memory-mcp": "0.1.76",
+    "@bli-cockpit/mcp": "0.1.157",
+    "@bli-cockpit/telemetry-core": "0.1.83"
   },
   "repository": {
     "type": "git",