@bli-cockpit/cli 0.2.49 → 0.2.51

package/dist/commands/backfill-upload.js

@@ -0,0 +1,212 @@
+import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET, } from "../adapters/raw-evidence.js";
+import { startLocalWorkContext } from "../local-state.js";
+import { LocalUploadBlockedError, syncLocalAmbientEnvelope, } from "../upload.js";
+import { buildBackfillBatches, uploadableCandidates, } from "./backfill-batches.js";
+import { candidateCursorKey } from "./backfill-candidates.js";
+import { countSessionUploadFailures, deferredEvidenceCount, durableBackfillCandidateKeys, } from "./backfill-evidence-outcomes.js";
+import { blockingScanIssues } from "./backfill-issues.js";
+import { writeLine } from "./backfill-output.js";
+const BACKFILL_MAX_CONSECUTIVE_FAILURES = 3;
+/**
+ * UPLOAD: sync every uploadable candidate in fixed-size batches, heartbeating
+ * the backfill lock between batches, stopping early on an exhausted budget or
+ * three consecutive failed batches. A candidate whose main is durably
+ * oversized-skipped (BLI-2727) is accounted for, not missing — it will never
+ * earn a durable pointer under the current cap, and treating it as "still
+ * missing" would fail every batch it happens to share with genuinely uploaded
+ * siblings, so it is excluded via `oversizedCandidateKeys` throughout.
+ */
+export async function uploadBackfillBatches(command, io, lock, ctx) {
+    const uploadable = uploadableCandidates(ctx.scan.candidates);
+    const batches = buildBackfillBatches(uploadable);
+    const rawEvidenceBudget = {
+        remainingBytes: RAW_EVIDENCE_DEFAULT_BYTE_BUDGET,
+        remainingObjects: RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET,
+    };
+    const tally = emptyUploadTally();
+    let consecutiveFailures = 0;
+    let blockedAt;
+    let failureReason = blockingScanIssues(ctx.scan.issues)[0]?.reason;
+    const stoppedAt = (what, index) => ({
+        what,
+        batch_index: index + 1,
+        batch_total: batches.length,
+        done: tally.done,
+        total: uploadable.length,
+    });
+    for (const [index, batch] of batches.entries()) {
+        await lock.handle.heartbeat();
+        const outcome = await uploadOneBackfillBatch(command, io, ctx, batch, rawEvidenceBudget);
+        foldBatchIntoTally(tally, batch, outcome);
+        consecutiveFailures = outcome.failed ? consecutiveFailures + 1 : 0;
+        if (!command.json) {
+            writeLine(io.stdout, `Uploaded ${tally.done}/${uploadable.length} (batch ${index + 1}/${batches.length})`);
+        }
+        await yieldToEventLoop();
+        if (outcome.deferred) {
+            blockedAt = stoppedAt("raw evidence budget exhausted", index);
+            failureReason = "deferred_budget_exhausted";
+            break;
+        }
+        if (consecutiveFailures >= BACKFILL_MAX_CONSECUTIVE_FAILURES) {
+            blockedAt = stoppedAt("consecutive upload failures", index);
+            failureReason = failedBatchReason(outcome.sync, outcome.missingDurableMain);
+            break;
+        }
+    }
+    return { ...tally, uploadable, batches, blockedAt, failureReason };
+}
+/** Uploads one batch and judges it; every judgement here is a named predicate. */
+async function uploadOneBackfillBatch(command, io, ctx, batch, rawEvidenceBudget) {
+    const sync = await syncBackfillBatch({
+        command,
+        batch,
+        worktrees: ctx.worktrees,
+        codexAttribution: ctx.scan.codexAttribution,
+        claudeAttribution: ctx.scan.claudeAttribution,
+        rawEvidenceBudget,
+        fetchImpl: io.fetch,
+    });
+    const durableInBatch = durableBackfillCandidateKeys(batch, sync);
+    const missingDurableMain = countMissingDurableMains(batch, durableInBatch, ctx.oversizedCandidateKeys);
+    return {
+        sync,
+        durableInBatch,
+        missingDurableMain,
+        failed: didBatchFail(sync, missingDurableMain),
+        deferred: deferredEvidenceCount(sync) > 0,
+    };
+}
+function emptyUploadTally() {
+    return {
+        syncResults: [],
+        completedBatches: 0,
+        failedBatches: 0,
+        done: 0,
+        failed: 0,
+        deferred: 0,
+        uploadedObjects: 0,
+        uploadedChunks: 0,
+        backfilledSessions: 0,
+        durableCandidateKeys: new Set(),
+    };
+}
+function foldBatchIntoTally(tally, batch, outcome) {
+    tally.syncResults.push(outcome.sync);
+    tally.done += batch.candidates.length;
+    tally.uploadedObjects += outcome.sync.raw_evidence_uploaded_object_count;
+    tally.uploadedChunks += outcome.sync.raw_evidence_uploaded_chunk_count;
+    tally.failed += countSessionUploadFailures(outcome.sync);
+    tally.deferred += deferredEvidenceCount(outcome.sync);
+    for (const key of outcome.durableInBatch)
+        tally.durableCandidateKeys.add(key);
+    tally.backfilledSessions = tally.durableCandidateKeys.size;
+    if (outcome.failed)
+        tally.failedBatches += 1;
+    if (!outcome.failed && !outcome.deferred)
+        tally.completedBatches += 1;
+}
+/**
+ * Candidates in this batch that still owe a durable main transcript. An
+ * oversized skip is excluded (BLI-2727): it can never earn a pointer under the
+ * current cap, and counting it here would fail every batch it happens to share
+ * with genuinely uploaded siblings.
+ */
+function countMissingDurableMains(batch, durableInBatch, oversizedCandidateKeys) {
+    return batch.candidates.filter((candidate) => !durableInBatch.has(candidateCursorKey(candidate)) &&
+        !oversizedCandidateKeys.has(candidateCursorKey(candidate))).length;
+}
+/** A batch counts as failed if it did not upload, lost a session, or left one pointerless. */
+function didBatchFail(sync, missingDurableMain) {
+    return (sync.status !== "uploaded" ||
+        countSessionUploadFailures(sync) > 0 ||
+        missingDurableMain > 0);
+}
+/** Names which of the three failure shapes ended the run, most specific first. */
+function failedBatchReason(sync, missingDurableMain) {
+    if (sync.status === "spooled")
+        return sync.failure_reason;
+    if (missingDurableMain > 0)
+        return "durable_session_pointer_missing";
+    return "upload_failed";
+}
+/**
+ * Hands one batch to the ordinary sync path. A batch whose repo has no local
+ * work context yet is not a failure — backfill routinely visits repos this
+ * machine has never synced — so that one blocker is answered by creating the
+ * context and retrying; every other error propagates.
+ */
+async function syncBackfillBatch(options) {
+    const syncOptions = backfillBatchSyncOptions(options);
+    try {
+        return await syncLocalAmbientEnvelope(syncOptions);
+    }
+    catch (error) {
+        if (error instanceof LocalUploadBlockedError &&
+            error.blocker === "missing_context") {
+            await startLocalWorkContext({
+                homeDir: options.command.homeDir,
+                repoRoot: options.batch.worktree.repo_root,
+                branch: options.batch.worktree.branch,
+            });
+            return await syncLocalAmbientEnvelope(syncOptions);
+        }
+        throw error;
+    }
+}
+/** The batch translated into the live sync path's envelope, session files and all. */
+function backfillBatchSyncOptions(options) {
+    return {
+        homeDir: options.command.homeDir,
+        repoRoot: options.batch.worktree.repo_root,
+        worktreeInventory: worktreeInventoryForRepo(options.batch.worktree, options.worktrees),
+        codexSessionFiles: options.batch.candidates
+            .filter((candidate) => candidate.source === "codex")
+            .map((candidate) => ({
+            local_path: candidate.file_path,
+            codex_session_id: candidate.session_id,
+        })),
+        codexAttributionScan: options.codexAttribution ?? undefined,
+        claudeSessionFiles: options.batch.candidates
+            .filter((candidate) => candidate.source === "claude_code")
+            .map((candidate) => ({
+            local_path: candidate.file_path,
+            claude_session_id: candidate.session_id,
+            main_file_oversized: Boolean(candidate.claude?.main_file_oversized),
+            skip_main: false,
+            sidecar_files: candidate.claude?.sidecar_files
+                .filter((sidecar) => !sidecar.skipped_reason)
+                .map((sidecar) => ({ local_path: sidecar.local_path })) ?? [],
+        })),
+        claudeAttributionScan: options.claudeAttribution ?? undefined,
+        rawEvidenceBudget: options.rawEvidenceBudget,
+        // `cockpit backfill` is only ever an operator asking — by hand, through
+        // onboarding, through doctor, or by running the retry command Cockpit
+        // printed. The delivery-backoff window is the scheduler's cadence, so it
+        // does not gate this pass: honouring it here made the retry that follows a
+        // failed commit a 15-minute no-op that reported
+        // `durable_session_pointer_missing` and never named the hold (BLI-3118).
+        evidenceDeliveryMode: "operator_retry",
+        fetch: options.fetchImpl,
+    };
+}
+function worktreeInventoryForRepo(current, worktrees) {
+    return worktrees
+        .filter((worktree) => worktree.repo_fingerprint
+        ? worktree.repo_fingerprint === current.repo_fingerprint
+        : worktree.repo_label === current.repo_label)
+        .map((worktree) => ({
+        repo: worktree.repo_root,
+        repo_label: worktree.repo_label,
+        repo_fingerprint: worktree.repo_fingerprint,
+        repo_origin_url: worktree.repo_origin_url ?? undefined,
+        head_sha: worktree.head_sha ?? undefined,
+        worktree_label: worktree.worktree_label,
+        worktree_fingerprint: worktree.worktree_fingerprint,
+        worktree_is_primary: worktree.worktree_is_primary,
+        branch: worktree.branch,
+    }));
+}
+function yieldToEventLoop() {
+    return new Promise((resolve) => setTimeout(resolve, 0));
+}