@bli-cockpit/cli 0.1.22 → 0.1.24

package/dist/onboarding-roots.js

@@ -0,0 +1,104 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+export const COLLECTION_ROOT_REQUIRED = "collection_root_required";
+export async function resolveOnboardingRoots(options) {
+    const explicitRoots = normalizeRoots(options.explicitRoots ?? []);
+    if (explicitRoots.length > 0) {
+        return { roots: explicitRoots, source: "explicit", confirmed: true };
+    }
+    const savedRoots = normalizeRoots([
+        ...(options.savedRoots ?? []),
+        ...(options.config?.default_repo_paths ?? []),
+    ]);
+    if (savedRoots.length > 0) {
+        if (!options.interactive) {
+            return { roots: savedRoots, source: "saved", confirmed: false };
+        }
+        const confirmed = await requirePrompt(options).confirm(savedRootsPrompt(savedRoots));
+        if (confirmed) {
+            return { roots: savedRoots, source: "saved", confirmed: true };
+        }
+        return promptForRoots(options, "Collection root(s), comma-separated: ");
+    }
+    if (!options.interactive) {
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: pass --workspace <path> or run cockpit onboard in a terminal to confirm a collection root.`);
+    }
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const cwdRoot = likelyBliRootFromCwd(cwd);
+    if (cwdRoot) {
+        const confirmed = await requirePrompt(options).confirm(`Collect from ${cwdRoot}? [Y/n] `);
+        if (confirmed) {
+            return { roots: [cwdRoot], source: "cwd_likely_root", confirmed: true };
+        }
+    }
+    const homeRoot = path.join(options.homeDir ?? os.homedir(), "BLI");
+    if (await directoryExists(homeRoot)) {
+        const confirmed = await requirePrompt(options).confirm(`I found ${homeRoot}. Collect from there? [Y/n] `);
+        if (confirmed) {
+            return { roots: [path.resolve(homeRoot)], source: "home_likely_root", confirmed: true };
+        }
+    }
+    return promptForRoots(options, "Collection root(s), comma-separated: ");
+}
+export function normalizeRoots(roots) {
+    const seen = new Set();
+    const normalized = [];
+    for (const root of roots) {
+        const trimmed = root.trim();
+        if (!trimmed)
+            continue;
+        for (const candidate of splitRootInput(trimmed)) {
+            const resolved = path.resolve(candidate);
+            if (resolved === path.parse(resolved).root)
+                continue;
+            if (resolved === os.homedir())
+                continue;
+            if (seen.has(resolved))
+                continue;
+            seen.add(resolved);
+            normalized.push(resolved);
+        }
+    }
+    return normalized;
+}
+function splitRootInput(value) {
+    return value
+        .split(/[,\n]/u)
+        .map((part) => part.trim())
+        .filter(Boolean);
+}
+async function promptForRoots(options, message) {
+    const prompt = requirePrompt(options);
+    const roots = normalizeRoots([await prompt.input(message)]);
+    if (roots.length === 0) {
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: no collection root confirmed; pass --workspace <path>.`);
+    }
+    return { roots, source: "prompt", confirmed: true };
+}
+function savedRootsPrompt(roots) {
+    if (roots.length === 1) {
+        return `I'm collecting from ${roots[0]}. Still true? [Y/n] `;
+    }
+    return [
+        "I'm collecting from:",
+        ...roots.map((root) => `- ${root}`),
+        "Still true? [Y/n] ",
+    ].join("\n");
+}
+function requirePrompt(options) {
+    if (!options.prompt) {
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: interactive prompt unavailable.`);
+    }
+    return options.prompt;
+}
+function likelyBliRootFromCwd(cwd) {
+    const parts = cwd.split(path.sep).filter(Boolean);
+    const index = parts.lastIndexOf("BLI");
+    if (index < 0)
+        return null;
+    return `${path.sep}${parts.slice(0, index + 1).join(path.sep)}`;
+}
+async function directoryExists(dir) {
+    return fs.stat(dir).then((stats) => stats.isDirectory(), () => false);
+}

package/dist/upload.js

@@ -162,7 +162,7 @@ export async function syncLocalAmbientEnvelope(options = {}) {
             uploadOutcomes = upload.outcomes;
             uploadedChunkCount = upload.uploaded_chunk_count;
         }
-        const envelope = pruneUndurablePointers(built.envelope, uploadOutcomes);
+        const envelope = applyRawEvidenceUploadOutcomes(built.envelope, uploadOutcomes);
         const response = await fetchImpl(`${built.dashboard_url}/api/ambient/ingest`, {
             method: "POST",
             headers: {
@@ -499,6 +499,7 @@ function rawEvidenceSummary(built, outcomes, uploadedChunkCount, cursor) {
         raw_evidence_uploaded_chunk_count: uploadedChunkCount,
         raw_evidence_reused_count: cursorReused.length + serverReusedCount,
         raw_evidence_failed_count: failed.length,
+        raw_evidence_sanitized_count: built.raw_evidence_facts?.sanitized_count ?? 0,
         raw_evidence_failure_reasons: [
             ...new Set(failed.map((outcome) => outcome.reason ?? "unknown")),
         ],
@@ -523,32 +524,40 @@ function rawEvidenceSummary(built, outcomes, uploadedChunkCount, cursor) {
 }
 /**
  * Ingest refuses pointers whose objects never became durable, so failed
- * uploads are pruned from the envelope instead of failing the whole sync;
- * the failures stay visible via reason labels and the server-side ledger.
+ * uploads are pruned from the envelope instead of failing the whole sync.
+ * Successful upload responses can also carry server-side sanitized hash and
+ * redaction metadata; apply those before ingest so refs describe the bytes
+ * actually stored in the durable bucket.
  */
-function pruneUndurablePointers(envelope, outcomes) {
+function applyRawEvidenceUploadOutcomes(envelope, outcomes) {
     // Content-addressed keys mean one pointer id can carry several outcomes
     // (byte-identical files); the pointer is durable if ANY outcome succeeded.
-    const durablePointerIds = new Set(outcomes
-        .filter((outcome) => outcome.upload_state !== "upload_failed")
-        .map((outcome) => outcome.pointer.raw_evidence_pointer_id));
+    const durablePointers = new Map();
+    for (const outcome of outcomes) {
+        if (outcome.upload_state === "upload_failed")
+            continue;
+        durablePointers.set(outcome.pointer.raw_evidence_pointer_id, outcome.pointer);
+    }
+    const durablePointerIds = new Set([...durablePointers.keys()]);
     const failedPointerIds = new Set(outcomes
         .filter((outcome) => outcome.upload_state === "upload_failed" &&
         !durablePointerIds.has(outcome.pointer.raw_evidence_pointer_id))
         .map((outcome) => outcome.pointer.raw_evidence_pointer_id));
     const failedOutcomes = outcomes.filter((outcome) => failedPointerIds.has(outcome.pointer.raw_evidence_pointer_id));
-    if (failedPointerIds.size === 0)
+    if (failedPointerIds.size === 0 && durablePointers.size === 0)
         return envelope;
     return {
         ...envelope,
         events: envelope.events.map((event) => ({
             ...event,
-            metrics: {
-                ...event.metrics,
-                evidence_failed_count: (event.metrics["evidence_failed_count"] ?? 0) +
-                    failedOutcomes.length,
-            },
-            attributes: event.evidence_completeness
+            metrics: failedPointerIds.size > 0
+                ? {
+                    ...event.metrics,
+                    evidence_failed_count: (event.metrics["evidence_failed_count"] ?? 0) +
+                        failedOutcomes.length,
+                }
+                : event.metrics,
+            attributes: failedPointerIds.size > 0 && event.evidence_completeness
                 ? {
                     ...event.attributes,
                     evidence_completeness_schema_version: event.evidence_completeness.schema_version,
@@ -556,14 +565,21 @@ function pruneUndurablePointers(envelope, outcomes) {
                     evidence_incomplete: true,
                 }
                 : event.attributes,
-            evidence_completeness: event.evidence_completeness
+            evidence_completeness: failedPointerIds.size > 0 && event.evidence_completeness
                 ? markCompletenessUploadFailures(event.evidence_completeness, failedOutcomes)
                 : event.evidence_completeness,
-            raw_evidence_pointers: event.raw_evidence_pointers.filter((pointer) => !failedPointerIds.has(pointer.raw_evidence_pointer_id)),
-            redaction: {
-                ...event.redaction,
-                raw_evidence_pointer_ids: event.redaction.raw_evidence_pointer_ids.filter((pointerId) => !failedPointerIds.has(pointerId)),
-            },
+            raw_evidence_pointers: event.raw_evidence_pointers.flatMap((pointer) => {
+                const pointerId = pointer.raw_evidence_pointer_id;
+                if (failedPointerIds.has(pointerId))
+                    return [];
+                return [durablePointers.get(pointerId) ?? pointer];
+            }),
+            redaction: failedPointerIds.size > 0
+                ? {
+                    ...event.redaction,
+                    raw_evidence_pointer_ids: event.redaction.raw_evidence_pointer_ids.filter((pointerId) => !failedPointerIds.has(pointerId)),
+                }
+                : event.redaction,
         })),
     };
 }
@@ -701,6 +717,7 @@ function makeSourceScanCompletedEvent(options) {
             raw_evidence_file_count: options.rawEvidenceFacts?.file_count ?? 0,
             raw_evidence_byte_size: options.rawEvidenceFacts?.byte_size ?? 0,
             raw_evidence_skipped_count: options.rawEvidenceFacts?.skipped_count ?? 0,
+            raw_evidence_sanitized_count: options.rawEvidenceFacts?.sanitized_count ?? 0,
             raw_evidence_reused_count: options.rawEvidenceFacts?.reused_count ?? 0,
             evidence_scanned_count: evidenceCompleteness?.totals.scanned_count ?? 0,
             evidence_included_count: evidenceCompleteness?.totals.included_count ?? 0,

package/package.json

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