@bli-cockpit/cli 0.2.149 → 0.2.154

package/dist/upload-sync.js

@@ -1,23 +1,3 @@
-/**
- * `syncLocalAmbientEnvelope`: one ambient sync, end to end.
- *
- * 1. Assemble the envelope — or record why this machine cannot upload at all
- *    and rethrow, so `cockpit status` names the blocker.
- * 2. Deliver the raw evidence objects, skipping anything inside its delivery
- *    backoff window (`upload-evidence-delivery.ts`).
- * 3. Reconcile the envelope with what actually became durable, POST it to
- *    ingest, and refuse to believe a receipt we cannot read
- *    (`upload-ingest-receipt.ts`).
- * 4. Advance the content cursor, report any agent images, and write the ledger
- *    row — a retry when a later sync could still rescue the gap, a named
- *    blocker when it never can, nothing extra when the sync was clean.
- * 5. On any failure, spool a retry that carries its own reason.
- *
- * The whole file is built around one rule from the fleet contract: a sync that
- * did not collect everything must never read green. Objects held by backoff are
- * reported as named failures, permanent rejections are logged and blocked
- * rather than silently retried forever, and the ledger row always says why.
- */
 import { getCollectorRuntimePaths } from "./local-state.js";
 import { uploadRawEvidenceFilesChunked, } from "./evidence-upload-client.js";
 import { markObjectCommitted, readRawEvidenceCursor, writeRawEvidenceCursor, } from "./cursors/raw-evidence-cursor.js";
@@ -80,7 +60,7 @@ export async function syncLocalAmbientEnvelope(options = {}) {
             built,
             envelope: applyRawEvidenceUploadOutcomes(built.envelope, uploadOutcomes),
         });
-        advanceRawEvidenceCursor(cursor, uploadOutcomes, attemptedAt);
+        advanceRawEvidenceCursor(cursor, uploadOutcomes, attemptedAt, built.raw_evidence_upload_files);
         await writeRawEvidenceCursor(paths, cursor);
         await reportAgentImageArtifacts({
             fetchImpl,
@@ -221,17 +201,25 @@ async function buildEnvelopeOrRecordBlocker(paths, options, cursorObjects, attem
  * bytes instead of re-uploading them. A failed upload is deliberately absent:
  * recording it would make the next sync skip a file that never landed.
  */
-function advanceRawEvidenceCursor(cursor, outcomes, attemptedAt) {
+function advanceRawEvidenceCursor(cursor, outcomes, attemptedAt, files = []) {
+    // BLI-11088: a transcript's source key and snapshot facts ride into the
+    // cursor, so the next sync can prove its snapshot rebuilds this one.
+    const snapshotByHash = new Map(files.filter((file) => file.snapshot && file.source_key && file.pointer.content_hash_sha256)
+        .map((file) => [file.pointer.content_hash_sha256, file]));
     for (const outcome of outcomes) {
         if (outcome.upload_state === "upload_failed")
             continue;
         const contentHash = outcome.pointer.content_hash_sha256;
         if (!contentHash)
             continue;
+        const source = snapshotByHash.get(contentHash);
         markObjectCommitted(cursor, contentHash, {
             object_key: outcome.object_key,
             byte_size: outcome.pointer.byte_size ?? 0,
             committed_at: attemptedAt,
+            ...(source
+                ? { source_key: source.source_key, checkpoints: source.snapshot.checkpoints }
+                : {}),
         });
     }
     cursor.updated_at = attemptedAt;

package/dist/warm-tower-fetch.js

@@ -0,0 +1,83 @@
+/**
+ * A CLI READ, ROUTED THROUGH THE RESIDENT MEMORY DAEMON'S WARM CONNECTION
+ * (BLI-10746).
+ *
+ * Every `cockpit` process today opens its own TCP+TLS connection to Tower —
+ * measured from Vietnam, about 420 ms of the ~1,700 ms `work list` takes is
+ * exactly that setup, paid fresh on every single command. `@bli-cockpit/
+ * memory-mcp`'s resident daemon already holds one connection open across
+ * turns for recall (BLI-10741); this module is "reuse that for every other
+ * read too" — a GET (or the one POST read this repo has, `memory search`)
+ * asks the daemon to replay it on its own dispatcher instead of opening a new
+ * socket.
+ *
+ * **Fallback is the whole safety argument.** A daemon that is absent, wedged,
+ * refuses, times out, or answers something this cannot parse means exactly
+ * one thing here: go the way this command always went. `isWarmRoutableRead`
+ * decides which requests are even eligible — writes NEVER take this path, so
+ * there is no daemon-retry-of-a-write hazard to reason about.
+ *
+ * **Auth never changes hands.** The caller's own `authorization` header
+ * travels inside `init.headers` exactly as `towerRequest` already built it;
+ * the daemon forwards it unread (see `@bli-cockpit/memory-mcp`'s
+ * `daemon/http-proxy.ts`). This module never reads the device token either.
+ */
+import os from "node:os";
+import { memoryDaemonEndpoint } from "@bli-cockpit/telemetry-core";
+import { askMemoryDaemonHttp, } from "@bli-cockpit/telemetry-core/node-daemon-http-client";
+/**
+ * The only POST this repo treats as a read for warm-routing purposes
+ * (`cockpit memory search`, `POST /api/memory/search`). Every other read is a
+ * GET; a caller names itself with the same `label` it already logs under.
+ */
+const WARM_ROUTABLE_POST_LABELS = new Set(["memory search"]);
+/** GET is always eligible; a small named allowlist covers the one read that is not. */
+export function isWarmRoutableRead(method, label) {
+    return method === "GET" || WARM_ROUTABLE_POST_LABELS.has(label);
+}
+/** The whole local-socket-plus-daemon's-own-fetch budget. Comfortably under any `READ_DEADLINE_MS` a command sets. */
+export const WARM_FETCH_DEADLINE_MS = 10_000;
+/**
+ * Tries the daemon; returns `null` on ANY reason it could not, so the caller
+ * falls back to a direct request. Never throws.
+ */
+export async function tryWarmTowerFetch(url, init, log, deps = {}) {
+    const endpoint = memoryDaemonEndpoint({
+        homeDir: deps.homeDir ?? os.homedir(),
+        ...(deps.platform ? { platform: deps.platform } : {}),
+        username: deps.username ?? safeUsername(),
+    });
+    if (endpoint.kind === "unix" && endpoint.addressTooLong) {
+        log(`[tower client] warm route skipped ${JSON.stringify({ reason: "socket_path_too_long" })}`);
+        return null;
+    }
+    const result = await askMemoryDaemonHttp({
+        address: endpoint.address,
+        deadlineMs: deps.deadlineMs ?? WARM_FETCH_DEADLINE_MS,
+        ...(deps.connectImpl ? { connectImpl: deps.connectImpl } : {}),
+        ...(deps.now ? { now: deps.now } : {}),
+        request: {
+            method: init.method,
+            url,
+            headers: init.headers,
+            ...(init.body === undefined ? {} : { body: init.body }),
+        },
+    });
+    if (!result.ok) {
+        log(`[tower client] warm route missed ${JSON.stringify({ reason: result.reason, elapsed_ms: result.elapsedMs })}`);
+        return null;
+    }
+    log(`[tower client] warm route used ${JSON.stringify({ elapsed_ms: result.elapsedMs })}`);
+    return new Response(result.answer.body, {
+        status: result.answer.status,
+        headers: result.answer.headers,
+    });
+}
+function safeUsername() {
+    try {
+        return os.userInfo().username;
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.149",
+  "version": "0.2.154",
   "private": false,
   "type": "module",
   "bin": {
@@ -24,11 +24,11 @@
     "pretypecheck": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/cli",
     "typecheck": "node -e \"await import('./dist/commands/public-root.js')\"",
     "pretest": "node ../../scripts/build-workspace-dep.mjs @bli-cockpit/cli",
-    "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-package-pack.mjs --workspace=@bli-cockpit/cli"
+    "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.38",
-    "@bli-cockpit/mcp": "0.1.72",
-    "@bli-cockpit/telemetry-core": "0.1.50"
+    "@bli-cockpit/memory-mcp": "0.1.41",
+    "@bli-cockpit/mcp": "0.1.75",
+    "@bli-cockpit/telemetry-core": "0.1.53"
   }
 }