@bli-cockpit/cli 0.1.29 → 0.1.31

package/dist/commands/session-sync.js

@@ -6,11 +6,13 @@
 import os from "node:os";
 import path from "node:path";
 import { getCollectorRuntimePaths, startLocalWorkContext, readLocalCollectorConfig } from "../local-state.js";
+import { CODEX_SESSION_ATTRIBUTION_STATE_RANK, } from "@bli-cockpit/telemetry-core";
 import { LocalUploadBlockedError, postCodexSessionReport, syncLocalAmbientEnvelope } from "../upload.js";
-import { CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT, CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
+import { CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT, CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES, defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { scanAndAttributeClaudeSessions } from "../adapters/claude-attribution.js";
 import { RAW_EVIDENCE_DEFAULT_BYTE_BUDGET, RAW_EVIDENCE_DEFAULT_OBJECT_BUDGET } from "../adapters/raw-evidence.js";
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, emptyRawEvidenceCursorState, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor } from "../cursors/raw-evidence-cursor.js";
+import { normalizeCollectionRoots } from "../root-normalization.js";
 const CLAUDE_FIRST_RUN_BACKFILL_MINUTES = 14 * 24 * 60;
 const CLAUDE_DAMP_GROWTH_BYTES = 256 * 1024;
 const CLAUDE_DAMP_MAX_AGE_MS = 6 * 60 * 60 * 1000;
@@ -28,13 +30,16 @@ export async function runAttributedWorktreeSync(options) {
     const now = new Date();
     const homeDir = options.homeDir ?? os.homedir();
     const paths = getCollectorRuntimePaths(options.homeDir);
-    const claudeEnabled = await isClaudeCollectionEnabled(paths);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
+    const claudeEnabled = config?.collect_claude_jsonl !== false;
+    const collectionRoots = fallbackCollectionRoots(config?.default_repo_paths ?? [], options.worktrees);
     const codexAttribution = await scanAndAttributeCodexSessions({
         sessionsDirs: defaultCodexSessionDirs(homeDir),
         worktrees: options.worktrees,
         now,
-        sinceMinutes: CODEX_ATTRIBUTION_BACKFILL_SINCE_MINUTES,
-        limit: CODEX_ATTRIBUTION_BACKFILL_SESSION_LIMIT,
+        sinceMinutes: CODEX_ATTRIBUTION_SCAN_WINDOW_MINUTES,
+        limit: CODEX_ATTRIBUTION_SCAN_WINDOW_SESSION_LIMIT,
+        collectionRoots,
     });
     // First run (D B.4 §8): without a Claude cursor yet, widen the window to 14
     // days so the first sync captures retroactive history instead of only 24h.
@@ -45,6 +50,7 @@ export async function runAttributedWorktreeSync(options) {
             projectsDir: path.join(homeDir, ".claude", "projects"),
             worktrees: options.worktrees,
             now,
+            collectionRoots,
             sinceMinutes: firstRunBackfill
                 ? CLAUDE_FIRST_RUN_BACKFILL_MINUTES
                 : undefined,
@@ -228,12 +234,7 @@ export async function runAttributedWorktreeSync(options) {
     });
     return { ok, outcomes, codexAttribution, claudeAttribution, summary };
 }
-const ATTRIBUTION_STATE_RANK = {
-    attributed: 3,
-    ambiguous: 2,
-    unattributed: 1,
-    skipped: 0,
-};
+export const ATTRIBUTION_STATE_RANK = CODEX_SESSION_ATTRIBUTION_STATE_RANK;
 function normalizeCodexResult(result) {
     return {
         source: "codex",
@@ -358,7 +359,8 @@ function buildAgentSessionReport(options) {
                         raw_evidence_pointer_id: priorDurablePointer,
                         upload_state: "reused_existing",
                     }
-                    : result.state === "attributed"
+                    : result.state === "attributed" ||
+                        result.state === "attributed_fallback"
                         ? { upload_state: "not_uploaded" }
                         : {}),
         };
@@ -442,6 +444,7 @@ function buildAgentSessionSummary(options) {
     const codex = {
         scanned: options.codexAttribution.scanned_file_count,
         attributed: options.codexAttribution.counts.attributed,
+        attributed_fallback: options.codexAttribution.counts.attributed_fallback,
         ambiguous: options.codexAttribution.counts.ambiguous,
         unattributed: options.codexAttribution.counts.unattributed,
         skipped: options.codexAttribution.counts.skipped,
@@ -450,6 +453,7 @@ function buildAgentSessionSummary(options) {
     const claude = {
         scanned: options.claudeAttribution.scanned_session_count,
         attributed: options.claudeAttribution.counts.attributed,
+        attributed_fallback: options.claudeAttribution.counts.attributed_fallback,
         ambiguous: options.claudeAttribution.counts.ambiguous,
         unattributed: options.claudeAttribution.counts.unattributed,
         skipped: options.claudeAttribution.counts.skipped,
@@ -470,6 +474,7 @@ function buildAgentSessionSummary(options) {
     return {
         scanned: codex.scanned,
         attributed: codex.attributed,
+        attributed_fallback: codex.attributed_fallback,
         ambiguous: codex.ambiguous,
         unattributed: codex.unattributed,
         skipped: codex.skipped,
@@ -501,6 +506,7 @@ function emptyClaudeScan() {
         disabled_reason: "claude_collection_disabled_by_config",
         counts: {
             attributed: 0,
+            attributed_fallback: 0,
             ambiguous: 0,
             unattributed: 0,
             skipped: 0,
@@ -528,9 +534,11 @@ function worktreeInventoryForRepo(current, worktrees) {
         branch: worktree.branch,
     }));
 }
-async function isClaudeCollectionEnabled(paths) {
-    const config = await readLocalCollectorConfig(paths).catch(() => null);
-    return config?.collect_claude_jsonl !== false;
+function fallbackCollectionRoots(savedRoots, worktrees) {
+    return normalizeCollectionRoots([
+        ...savedRoots,
+        ...worktrees.map((worktree) => worktree.requested_path || worktree.repo_root),
+    ]);
 }
 async function fileExists(filePath) {
     const { stat } = await import("node:fs/promises");

package/dist/cursors/backfill-cursor.js

@@ -0,0 +1,130 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+export const BACKFILL_CURSOR_FILENAME = "backfill.json";
+export const BACKFILL_COMPLETION_MARKER_FILENAME = "backfill-complete.json";
+export function emptyBackfillCursorState() {
+    return {
+        schema_version: "cockpit-backfill-cursor.v1",
+        updated_at: null,
+        sources: {
+            codex: emptySourceCursor(),
+            claude_code: emptySourceCursor(),
+        },
+    };
+}
+export async function readBackfillCursor(paths) {
+    try {
+        const raw = JSON.parse(await fs.readFile(backfillCursorPath(paths), "utf8"));
+        return parseBackfillCursor(raw);
+    }
+    catch {
+        return emptyBackfillCursorState();
+    }
+}
+export async function writeBackfillCursor(paths, state) {
+    const filePath = backfillCursorPath(paths);
+    await writePrivateJson(filePath, state);
+}
+export async function writeBackfillCompletionMarker(paths, marker) {
+    await writePrivateJson(backfillCompletionMarkerPath(paths), marker);
+}
+export function recordBackfillCursorObservations(cursor, observations, now) {
+    for (const observation of observations) {
+        const source = cursor.sources[observation.source] ?? emptySourceCursor();
+        const oldest = source.oldest_mtime_ms_processed;
+        if (oldest === null ||
+            observation.session_file_mtime_ms < oldest) {
+            source.oldest_mtime_ms_processed = observation.session_file_mtime_ms;
+            source.oldest_mtime_processed = observation.session_file_mtime;
+        }
+        source.state_counts[observation.state] =
+            (source.state_counts[observation.state] ?? 0) + 1;
+        source.reason_counts[observation.reason] =
+            (source.reason_counts[observation.reason] ?? 0) + 1;
+        cursor.sources[observation.source] = source;
+    }
+    cursor.updated_at = now.toISOString();
+}
+export function backfillCursorPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_CURSOR_FILENAME);
+}
+export function backfillCompletionMarkerPath(paths) {
+    return path.join(paths.cursors_dir, BACKFILL_COMPLETION_MARKER_FILENAME);
+}
+function emptySourceCursor() {
+    return {
+        oldest_mtime_ms_processed: null,
+        oldest_mtime_processed: null,
+        state_counts: {},
+        reason_counts: {},
+    };
+}
+function parseBackfillCursor(value) {
+    if (!value || typeof value !== "object")
+        return emptyBackfillCursorState();
+    const record = value;
+    const sources = record["sources"];
+    const parsed = emptyBackfillCursorState();
+    parsed.updated_at = optionalString(record["updated_at"]);
+    if (sources && typeof sources === "object") {
+        const sourceRecord = sources;
+        parsed.sources.codex = parseSourceCursor(sourceRecord["codex"]);
+        parsed.sources.claude_code = parseSourceCursor(sourceRecord["claude_code"]);
+    }
+    return parsed;
+}
+function parseSourceCursor(value) {
+    if (!value || typeof value !== "object")
+        return emptySourceCursor();
+    const record = value;
+    const oldest = optionalNumber(record["oldest_mtime_ms_processed"]);
+    return {
+        oldest_mtime_ms_processed: oldest,
+        oldest_mtime_processed: optionalString(record["oldest_mtime_processed"]) ??
+            (oldest === null ? null : new Date(oldest).toISOString()),
+        state_counts: parseNumberRecord(record["state_counts"]),
+        reason_counts: parseNumberRecord(record["reason_counts"]),
+    };
+}
+function parseNumberRecord(value) {
+    if (!value || typeof value !== "object")
+        return {};
+    const out = {};
+    for (const [key, raw] of Object.entries(value)) {
+        if (typeof raw === "number" && Number.isFinite(raw) && raw >= 0) {
+            out[key] = Math.floor(raw);
+        }
+    }
+    return out;
+}
+async function writePrivateJson(filePath, value) {
+    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
+    const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+    const serialized = `${JSON.stringify(value, null, 2)}\n`;
+    let handle = null;
+    try {
+        handle = await fs.open(tempPath, "w", 0o600);
+        await handle.writeFile(serialized);
+        await handle.sync();
+    }
+    finally {
+        await handle?.close();
+    }
+    try {
+        await fs.rename(tempPath, filePath);
+    }
+    catch (error) {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+        throw error;
+    }
+    if (process.platform !== "win32") {
+        await fs.chmod(filePath, 0o600).catch(() => undefined);
+    }
+}
+function optionalString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function optionalNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}

package/dist/evidence-upload-client.js

@@ -12,6 +12,22 @@ export async function uploadRawEvidenceFilesChunked(options) {
     const loaded = [];
     const loadedByObjectKey = new Map();
     for (const file of options.files) {
+        let stat;
+        try {
+            stat = await fs.stat(file.local_path);
+        }
+        catch {
+            outcomes.push(failedOutcome(file, "file_read_failed"));
+            continue;
+        }
+        if (stat.size === 0) {
+            outcomes.push(failedOutcome(file, "empty_file"));
+            continue;
+        }
+        if (stat.size > RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
+            outcomes.push(failedOutcome(file, "file_too_large"));
+            continue;
+        }
         let bytes;
         try {
             bytes = await fs.readFile(file.local_path);

package/dist/upload.js

@@ -1,4 +1,4 @@
-import { AgentImageArtifactReportRequestSchema, EvidenceCompletenessPayloadSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
+import { AgentImageArtifactReportRequestSchema, CODEX_SESSION_REPORT_MAX_SESSIONS, CodexSessionAttributionReportResponseSchema, EvidenceCompletenessPayloadSchema, TelemetryIngestEnvelopeSchema, TelemetryIngestEventDtoSchema, } from "@bli-cockpit/telemetry-core";
 import path from "node:path";
 import { getCollectorRuntimePaths, LOCAL_COLLECTOR_VERSION, readLocalCollectorConfig, readLocalCollectorSessionFile, readLocalSessionReference, readLocalWorkContextForRepo, } from "./local-state.js";
 import { runLocalSourceCollectors } from "./adapters/local-sources.js";
@@ -279,7 +279,7 @@ export async function syncLocalAmbientEnvelope(options = {}) {
  */
 export async function postCodexSessionReport(options) {
     if (options.sessions.length === 0) {
-        return { posted: false, reason: "no_sessions_observed" };
+        return emptyCodexSessionReportResult("no_sessions_observed");
     }
     const fetchImpl = options.fetch ?? globalThis.fetch;
     if (!fetchImpl) {
@@ -291,7 +291,7 @@ export async function postCodexSessionReport(options) {
         const sessionFile = await readLocalCollectorSessionFile(paths);
         const session = await readLocalSessionReference(paths);
         if (session.session_state !== "valid") {
-            return { posted: false, reason: "collector_not_paired" };
+            return emptyCodexSessionReportResult("collector_not_paired");
         }
         const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
         const activeContext = await readLocalWorkContextForRepo(paths, repoRoot);
@@ -316,7 +316,7 @@ export async function postCodexSessionReport(options) {
         });
     }
     catch {
-        return { posted: false, reason: "collector_not_ready" };
+        return emptyCodexSessionReportResult("collector_not_ready");
     }
 }
 /**
@@ -326,33 +326,122 @@ export async function postCodexSessionReport(options) {
  */
 export async function reportCodexSessionAttributions(options) {
     if (options.sessions.length === 0) {
-        return { posted: false, reason: "no_sessions_observed" };
+        return emptyCodexSessionReportResult("no_sessions_observed");
     }
-    try {
-        const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/codex-sessions`, {
-            method: "POST",
-            headers: {
-                "Authorization": `Bearer ${options.deviceToken}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-                schema_version: "ambient-codex-session-attributions.v1",
-                generated_at: options.generatedAt,
-                provenance: options.provenance,
-                sessions: options.sessions,
-            }),
+    const chunks = [];
+    const sessionChunks = chunkArray(options.sessions, CODEX_SESSION_REPORT_MAX_SESSIONS);
+    for (const [index, sessions] of sessionChunks.entries()) {
+        const chunk = await postCodexSessionAttributionChunk({
+            ...options,
+            sessions,
+            batchIndex: index + 1,
         });
-        if (response.status === 404) {
-            return { posted: false, reason: "codex_session_api_unavailable" };
+        chunks.push(chunk);
+    }
+    const failedCount = chunks.filter((chunk) => !chunk.posted).length;
+    const recordedCount = chunks.reduce((sum, chunk) => sum + chunk.recorded_count, 0);
+    return {
+        posted: failedCount === 0,
+        reason: failedCount === 0
+            ? "recorded"
+            : chunks.find((chunk) => !chunk.posted)?.reason ?? "report_failed",
+        chunk_count: chunks.length,
+        recorded_count: recordedCount,
+        failed_count: failedCount,
+        chunks,
+    };
+}
+async function postCodexSessionAttributionChunk(options) {
+    const maxAttempts = options.maxAttemptsPerRequest ?? 3;
+    const sleep = options.sleep ?? defaultReportSleep;
+    let lastStatus = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const response = await options.fetchImpl(`${options.dashboardUrl}/api/ambient/codex-sessions`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${options.deviceToken}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify({
+                    schema_version: "ambient-codex-session-attributions.v1",
+                    generated_at: options.generatedAt,
+                    provenance: options.provenance,
+                    sessions: options.sessions,
+                }),
+            });
+            lastStatus = response.status;
+            const body = await readResponseJson(response);
+            if (response.status === 404) {
+                return codexSessionReportChunkResult(options, {
+                    posted: false,
+                    reason: "codex_session_api_unavailable",
+                    httpStatus: response.status,
+                    recordedCount: 0,
+                });
+            }
+            if (response.ok) {
+                const parsed = CodexSessionAttributionReportResponseSchema.safeParse(body);
+                return codexSessionReportChunkResult(options, {
+                    posted: true,
+                    reason: "recorded",
+                    httpStatus: response.status,
+                    recordedCount: parsed.success ? parsed.data.recorded_count : 0,
+                });
+            }
+            if (response.status < 500 && response.status !== 429) {
+                return codexSessionReportChunkResult(options, {
+                    posted: false,
+                    reason: `report_failed_http_${response.status}`,
+                    httpStatus: response.status,
+                    recordedCount: 0,
+                });
+            }
         }
-        if (!response.ok) {
-            return { posted: false, reason: `report_failed_http_${response.status}` };
+        catch {
+            lastStatus = null;
         }
-        return { posted: true, reason: "recorded" };
+        if (attempt < maxAttempts)
+            await sleep(250 * attempt);
     }
-    catch {
-        return { posted: false, reason: "report_network_error" };
+    return codexSessionReportChunkResult(options, {
+        posted: false,
+        reason: lastStatus === null
+            ? "report_network_error"
+            : `report_failed_http_${lastStatus}`,
+        httpStatus: lastStatus,
+        recordedCount: 0,
+    });
+}
+function codexSessionReportChunkResult(options, result) {
+    return {
+        batch_index: options.batchIndex,
+        session_count: options.sessions.length,
+        posted: result.posted,
+        reason: result.reason,
+        http_status: result.httpStatus,
+        recorded_count: result.recordedCount,
+    };
+}
+function emptyCodexSessionReportResult(reason) {
+    return {
+        posted: false,
+        reason,
+        chunk_count: 0,
+        recorded_count: 0,
+        failed_count: 0,
+        chunks: [],
+    };
+}
+function chunkArray(items, size) {
+    const chunks = [];
+    for (let offset = 0; offset < items.length; offset += size) {
+        chunks.push(items.slice(offset, offset + size));
     }
+    return chunks;
+}
+function defaultReportSleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
 export async function reportAgentImageArtifacts(options) {
     const artifacts = agentArtifactsFromEvidence(options);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.1.29",
+  "version": "0.1.31",
   "private": false,
   "type": "module",
   "bin": {
@@ -26,6 +26,6 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/telemetry-core": "0.1.9"
+    "@bli-cockpit/telemetry-core": "0.1.11"
   }
 }