@bli-cockpit/cli 0.2.5 → 0.2.8

package/dist/root-normalization.js

@@ -1,12 +1,13 @@
 import path from "node:path";
-export function collapseAncestorRoots(roots) {
+export function collapseAncestorRoots(roots, pathApi = path) {
     const collapsed = [];
     for (const root of roots) {
-        const resolved = path.resolve(root);
-        if (collapsed.some((existing) => containsPath(existing, resolved)))
+        const resolved = pathApi.resolve(root);
+        if (collapsed.some((existing) => containsPath(existing, resolved, pathApi))) {
             continue;
+        }
         for (let index = collapsed.length - 1; index >= 0; index -= 1) {
-            if (containsPath(resolved, collapsed[index])) {
+            if (containsPath(resolved, collapsed[index], pathApi)) {
                 collapsed.splice(index, 1);
             }
         }
@@ -14,21 +15,33 @@ export function collapseAncestorRoots(roots) {
     }
     return collapsed;
 }
-export function normalizeCollectionRoots(roots) {
-    const collapsed = collapseAncestorRoots(roots);
-    if (!collapsed.some(isBliWorkspaceRoot))
+export function normalizeCollectionRoots(roots, pathApi = path) {
+    const collapsed = collapseAncestorRoots(roots, pathApi);
+    if (!collapsed.some((root) => isBliWorkspaceRoot(root, pathApi))) {
         return collapsed;
-    return collapsed.filter((root) => !isCodexWorktreePath(root));
+    }
+    return collapsed.filter((root) => !isCodexWorktreePath(root, pathApi));
 }
-function containsPath(parent, candidate) {
-    const relative = path.relative(parent, candidate);
+export function containsPath(parent, candidate, pathApi = path) {
+    const relative = pathApi.relative(parent, candidate);
     return (relative === "" ||
-        (!!relative && !relative.startsWith("..") && !path.isAbsolute(relative)));
+        (!!relative &&
+            relative !== ".." &&
+            !relative.startsWith(`..${pathApi.sep}`) &&
+            !pathApi.isAbsolute(relative)));
+}
+export function isSamePath(left, right, pathApi = path) {
+    return pathApi.relative(left, right) === "";
+}
+function comparableSegment(value, pathApi) {
+    return pathApi.sep === "\\" ? value.toLowerCase() : value;
 }
-function isBliWorkspaceRoot(root) {
-    return path.basename(root) === "BLI";
+function isBliWorkspaceRoot(root, pathApi) {
+    return comparableSegment(pathApi.basename(root), pathApi) ===
+        comparableSegment("BLI", pathApi);
 }
-function isCodexWorktreePath(root) {
-    const parts = root.split(path.sep).filter(Boolean);
-    return parts.some((part, index) => part === ".codex" && parts[index + 1] === "worktrees");
+export function isCodexWorktreePath(root, pathApi = path) {
+    const parts = root.split(pathApi.sep).filter(Boolean);
+    return parts.some((part, index) => comparableSegment(part, pathApi) === ".codex" &&
+        comparableSegment(parts[index + 1] ?? "", pathApi) === "worktrees");
 }

package/dist/spool/local-spool.js

@@ -1,6 +1,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import path from "node:path";
+import { CodexSessionAttributionSchema, } from "@bli-cockpit/telemetry-core";
 const SPOOL_STATE_FILENAME = "upload-state.json";
 const MAX_PENDING_UPLOADS = 20;
 export function emptyUploadSpoolState() {
@@ -11,15 +12,33 @@ export function emptyUploadSpoolState() {
         last_upload_success_at: null,
         last_upload_failure_reason: null,
         pending_uploads: [],
+        pending_source_retries: [],
+        pending_session_reports: [],
     };
 }
 export async function readLocalUploadSpoolState(paths) {
+    const filePath = uploadSpoolStatePath(paths);
+    let serialized;
+    try {
+        serialized = await fs.readFile(filePath, "utf8");
+    }
+    catch (error) {
+        if (isErrnoException(error, "ENOENT"))
+            return emptyUploadSpoolState();
+        throw uploadSpoolReadError(filePath, "unreadable", error);
+    }
+    let raw;
+    try {
+        raw = JSON.parse(serialized);
+    }
+    catch (error) {
+        throw uploadSpoolReadError(filePath, "invalid JSON", error);
+    }
     try {
-        const raw = JSON.parse(await fs.readFile(uploadSpoolStatePath(paths), "utf8"));
         return parseUploadSpoolState(raw);
     }
-    catch {
-        return emptyUploadSpoolState();
+    catch (error) {
+        throw uploadSpoolReadError(filePath, "invalid schema", error);
     }
 }
 export async function summarizeLocalUploadSpool(paths) {
@@ -28,8 +47,14 @@ export async function summarizeLocalUploadSpool(paths) {
         last_upload_attempt_at: state.last_upload_attempt_at,
         last_upload_success_at: state.last_upload_success_at,
         last_upload_failure_reason: state.last_upload_failure_reason,
-        pending_upload_count: state.pending_uploads.length,
-        retry_command: state.pending_uploads[0]?.retry_command ?? null,
+        pending_upload_count: state.pending_uploads.length +
+            state.pending_source_retries.length +
+            state.pending_session_reports.length,
+        retry_command: state.pending_uploads[0]?.retry_command ??
+            (state.pending_source_retries.length > 0 ||
+                state.pending_session_reports.length > 0
+                ? "cockpit sync"
+                : null),
     };
 }
 export async function recordUploadBlocked(paths, options) {
@@ -45,13 +70,19 @@ export async function recordUploadBlocked(paths, options) {
 }
 export async function recordUploadSuccess(paths, options) {
     const state = await readLocalUploadSpoolState(paths);
+    const pending = options.clearPendingForContext === false
+        ? state.pending_uploads
+        : state.pending_uploads.filter((entry) => entry.work_context_id !== options.workContextId);
     const next = {
         ...state,
         updated_at: options.attemptedAt,
         last_upload_attempt_at: options.attemptedAt,
         last_upload_success_at: options.attemptedAt,
-        last_upload_failure_reason: null,
-        pending_uploads: [],
+        last_upload_failure_reason: firstPendingFailureReason({
+            ...state,
+            pending_uploads: pending,
+        }),
+        pending_uploads: pending,
     };
     await writeUploadSpoolState(paths, next);
     return next;
@@ -78,69 +109,315 @@ export async function recordUploadFailure(paths, entry) {
     });
     return spoolEntry;
 }
+export async function recordSourceRetryFailure(paths, options) {
+    const state = await readLocalUploadSpoolState(paths);
+    const retryEntry = {
+        source: options.source,
+        reason: options.reason,
+        last_attempt_at: options.attemptedAt,
+    };
+    const next = {
+        ...state,
+        updated_at: options.attemptedAt,
+        last_upload_attempt_at: options.attemptedAt,
+        last_upload_failure_reason: options.reason,
+        pending_source_retries: [
+            retryEntry,
+            ...state.pending_source_retries.filter((entry) => entry.source !== options.source),
+        ],
+    };
+    await writeUploadSpoolState(paths, next);
+    return next;
+}
+export async function clearSourceRetryFailure(paths, source, attemptedAt) {
+    const state = await readLocalUploadSpoolState(paths);
+    const next = {
+        ...state,
+        updated_at: attemptedAt,
+        pending_source_retries: state.pending_source_retries.filter((entry) => entry.source !== source),
+    };
+    next.last_upload_failure_reason = firstPendingFailureReason(next);
+    await writeUploadSpoolState(paths, next);
+    return next;
+}
+export async function recordPendingSessionReport(paths, entry) {
+    const state = await readLocalUploadSpoolState(paths);
+    const existing = state.pending_session_reports.find((candidate) => candidate.work_context_id === entry.work_context_id);
+    const safeIncomingSessions = parseMetadataOnlySessionReportRows(entry.sessions, "pending_session_report.sessions");
+    const mergedSessions = mergeSessionReportRows(existing?.sessions ?? [], safeIncomingSessions);
+    const pending = {
+        report_id: existing?.report_id ?? `session-report-${crypto.randomUUID()}`,
+        created_at: existing?.created_at ?? entry.attempted_at,
+        last_attempt_at: entry.attempted_at,
+        dashboard_url: entry.dashboard_url,
+        generated_at: entry.generated_at,
+        work_context_id: entry.work_context_id,
+        repo_label: entry.repo_label,
+        branch: entry.branch,
+        repo_fingerprint: entry.repo_fingerprint,
+        repo_origin_url: entry.repo_origin_url,
+        worktree_label: entry.worktree_label,
+        worktree_fingerprint: entry.worktree_fingerprint,
+        worktree_is_primary: entry.worktree_is_primary,
+        sessions: mergedSessions,
+        failure_reason: entry.failure_reason ?? "session_report_pending",
+    };
+    const next = {
+        ...state,
+        updated_at: entry.attempted_at,
+        last_upload_attempt_at: entry.attempted_at,
+        last_upload_failure_reason: pending.failure_reason,
+        pending_session_reports: [
+            pending,
+            ...state.pending_session_reports.filter((candidate) => candidate.report_id !== pending.report_id),
+        ],
+    };
+    await writeUploadSpoolState(paths, next);
+    return pending;
+}
+export async function recordSessionReportFailure(paths, options) {
+    const state = await readLocalUploadSpoolState(paths);
+    const next = {
+        ...state,
+        updated_at: options.attemptedAt,
+        last_upload_attempt_at: options.attemptedAt,
+        last_upload_failure_reason: options.reason,
+        pending_session_reports: state.pending_session_reports.map((entry) => entry.report_id === options.reportId
+            ? {
+                ...entry,
+                last_attempt_at: options.attemptedAt,
+                failure_reason: options.reason,
+            }
+            : entry),
+    };
+    await writeUploadSpoolState(paths, next);
+    return next;
+}
+export async function recordSessionReportSuccess(paths, options) {
+    const state = await readLocalUploadSpoolState(paths);
+    const next = {
+        ...state,
+        updated_at: options.attemptedAt,
+        last_upload_attempt_at: options.attemptedAt,
+        last_upload_success_at: options.attemptedAt,
+        pending_session_reports: state.pending_session_reports.filter((entry) => entry.report_id !== options.reportId),
+    };
+    next.last_upload_failure_reason = firstPendingFailureReason(next);
+    await writeUploadSpoolState(paths, next);
+    return next;
+}
 function parseUploadSpoolState(value) {
-    if (!value || typeof value !== "object")
-        return emptyUploadSpoolState();
-    const record = value;
+    const record = requireRecord(value, "root");
+    if (record["schema_version"] !== "cockpit-upload-spool.v1") {
+        invalidUploadSpoolState("schema_version", 'literal "cockpit-upload-spool.v1"');
+    }
     return {
         schema_version: "cockpit-upload-spool.v1",
-        updated_at: optionalString(record["updated_at"]),
-        last_upload_attempt_at: optionalString(record["last_upload_attempt_at"]),
-        last_upload_success_at: optionalString(record["last_upload_success_at"]),
-        last_upload_failure_reason: optionalString(record["last_upload_failure_reason"]),
-        pending_uploads: Array.isArray(record["pending_uploads"])
-            ? record["pending_uploads"]
-                .map(parseUploadSpoolEntry)
-                .filter((entry) => Boolean(entry))
-            : [],
-    };
-}
-function parseUploadSpoolEntry(value) {
-    if (!value || typeof value !== "object")
-        return null;
-    const record = value;
-    const spoolId = optionalString(record["spool_id"]);
-    const createdAt = optionalString(record["created_at"]);
-    const lastAttemptAt = optionalString(record["last_attempt_at"]);
-    const dashboardUrl = optionalString(record["dashboard_url"]);
-    const failureReason = optionalString(record["failure_reason"]);
-    const retryCommand = optionalString(record["retry_command"]);
-    if (!spoolId || !createdAt || !lastAttemptAt || !dashboardUrl || !failureReason) {
-        return null;
-    }
+        updated_at: requireNullableString(record["updated_at"], "updated_at"),
+        last_upload_attempt_at: requireNullableString(record["last_upload_attempt_at"], "last_upload_attempt_at"),
+        last_upload_success_at: requireNullableString(record["last_upload_success_at"], "last_upload_success_at"),
+        last_upload_failure_reason: requireNullableString(record["last_upload_failure_reason"], "last_upload_failure_reason"),
+        pending_uploads: requireArray(record["pending_uploads"], "pending_uploads").map((entry, index) => parseUploadSpoolEntry(entry, `pending_uploads[${index}]`)),
+        // These fields were added without changing the v1 schema version. Missing
+        // fields are therefore a valid legacy state, while present malformed fields
+        // must fail closed instead of being silently discarded.
+        pending_source_retries: optionalArray(record["pending_source_retries"], "pending_source_retries").map((entry, index) => parseSourceRetryEntry(entry, `pending_source_retries[${index}]`)),
+        pending_session_reports: optionalArray(record["pending_session_reports"], "pending_session_reports").map((entry, index) => parsePendingSessionReport(entry, `pending_session_reports[${index}]`)),
+    };
+}
+function parseUploadSpoolEntry(value, fieldPath) {
+    const record = requireRecord(value, fieldPath);
+    const retryCommand = record["retry_command"] === undefined
+        ? "cockpit sync"
+        : requireString(record["retry_command"], `${fieldPath}.retry_command`);
     return {
-        spool_id: spoolId,
-        created_at: createdAt,
-        last_attempt_at: lastAttemptAt,
-        dashboard_url: dashboardUrl,
-        work_context_id: optionalString(record["work_context_id"]),
-        ticket_id: optionalString(record["ticket_id"]),
-        repo_label: optionalString(record["repo_label"]),
-        branch: optionalString(record["branch"]),
-        event_count: optionalNumber(record["event_count"]),
-        source_scan_count: optionalNumber(record["source_scan_count"]),
-        risk_flag_count: optionalNumber(record["risk_flag_count"]),
-        raw_evidence_file_count: optionalNumber(record["raw_evidence_file_count"]),
-        failure_reason: failureReason,
-        retry_command: retryCommand ?? "cockpit sync",
+        spool_id: requireString(record["spool_id"], `${fieldPath}.spool_id`),
+        created_at: requireString(record["created_at"], `${fieldPath}.created_at`),
+        last_attempt_at: requireString(record["last_attempt_at"], `${fieldPath}.last_attempt_at`),
+        dashboard_url: requireString(record["dashboard_url"], `${fieldPath}.dashboard_url`),
+        work_context_id: requireNullableString(record["work_context_id"], `${fieldPath}.work_context_id`),
+        ticket_id: requireNullableString(record["ticket_id"], `${fieldPath}.ticket_id`),
+        repo_label: requireNullableString(record["repo_label"], `${fieldPath}.repo_label`),
+        branch: requireNullableString(record["branch"], `${fieldPath}.branch`),
+        event_count: requireNonNegativeInteger(record["event_count"], `${fieldPath}.event_count`),
+        source_scan_count: requireNonNegativeInteger(record["source_scan_count"], `${fieldPath}.source_scan_count`),
+        risk_flag_count: requireNonNegativeInteger(record["risk_flag_count"], `${fieldPath}.risk_flag_count`),
+        raw_evidence_file_count: requireNonNegativeInteger(record["raw_evidence_file_count"], `${fieldPath}.raw_evidence_file_count`),
+        retry_sources: parseRetrySources(record["retry_sources"], `${fieldPath}.retry_sources`),
+        failure_reason: requireString(record["failure_reason"], `${fieldPath}.failure_reason`),
+        retry_command: retryCommand,
     };
 }
 async function writeUploadSpoolState(paths, state) {
     const filePath = uploadSpoolStatePath(paths);
-    await fs.mkdir(path.dirname(filePath), { recursive: true, mode: 0o700 });
-    await fs.writeFile(filePath, `${JSON.stringify(state, null, 2)}\n`, {
-        mode: 0o600,
-    });
-    if (process.platform !== "win32") {
-        await fs.chmod(filePath, 0o600).catch(() => undefined);
+    const directoryPath = path.dirname(filePath);
+    const serialized = serializeUploadSpoolState(state);
+    const tempPath = path.join(directoryPath, `.${path.basename(filePath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    await fs.mkdir(directoryPath, { recursive: true, mode: 0o700 });
+    let handle = null;
+    let tempCreated = false;
+    let renamed = false;
+    try {
+        handle = await fs.open(tempPath, "wx", 0o600);
+        tempCreated = true;
+        if (process.platform !== "win32") {
+            await handle.chmod(0o600);
+        }
+        await handle.writeFile(serialized, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await fs.rename(tempPath, filePath);
+        renamed = true;
+        await fsyncDirectoryBestEffort(directoryPath);
     }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        if (tempCreated && !renamed) {
+            await fs.unlink(tempPath).catch(() => undefined);
+        }
+        throw error;
+    }
+}
+function serializeUploadSpoolState(state) {
+    const json = JSON.stringify(state);
+    const canonical = parseUploadSpoolState(JSON.parse(json));
+    return `${JSON.stringify(canonical, null, 2)}\n`;
 }
 function uploadSpoolStatePath(paths) {
     return path.join(paths.spool_dir, SPOOL_STATE_FILENAME);
 }
-function optionalString(value) {
-    return typeof value === "string" && value.trim() ? value : null;
+function parseRetrySources(value, fieldPath) {
+    if (value === undefined)
+        return [];
+    const values = requireArray(value, fieldPath);
+    return [...new Set(values.map((source) => parseRetrySource(source, fieldPath)))];
+}
+function parseSourceRetryEntry(value, fieldPath) {
+    const record = requireRecord(value, fieldPath);
+    return {
+        source: parseRetrySource(record["source"], `${fieldPath}.source`),
+        reason: requireString(record["reason"], `${fieldPath}.reason`),
+        last_attempt_at: requireString(record["last_attempt_at"], `${fieldPath}.last_attempt_at`),
+    };
+}
+function parsePendingSessionReport(value, fieldPath) {
+    const record = requireRecord(value, fieldPath);
+    const sessions = parseMetadataOnlySessionReportRows(record["sessions"], `${fieldPath}.sessions`);
+    return {
+        report_id: requireString(record["report_id"], `${fieldPath}.report_id`),
+        created_at: requireString(record["created_at"], `${fieldPath}.created_at`),
+        last_attempt_at: requireString(record["last_attempt_at"], `${fieldPath}.last_attempt_at`),
+        dashboard_url: requireString(record["dashboard_url"], `${fieldPath}.dashboard_url`),
+        generated_at: requireString(record["generated_at"], `${fieldPath}.generated_at`),
+        work_context_id: requireString(record["work_context_id"], `${fieldPath}.work_context_id`),
+        repo_label: requireString(record["repo_label"], `${fieldPath}.repo_label`),
+        branch: requireString(record["branch"], `${fieldPath}.branch`),
+        repo_fingerprint: requireString(record["repo_fingerprint"], `${fieldPath}.repo_fingerprint`),
+        repo_origin_url: record["repo_origin_url"] === undefined
+            ? null
+            : requireNullableString(record["repo_origin_url"], `${fieldPath}.repo_origin_url`),
+        worktree_label: requireString(record["worktree_label"], `${fieldPath}.worktree_label`),
+        worktree_fingerprint: requireString(record["worktree_fingerprint"], `${fieldPath}.worktree_fingerprint`),
+        worktree_is_primary: requireBoolean(record["worktree_is_primary"], `${fieldPath}.worktree_is_primary`),
+        sessions,
+        failure_reason: requireString(record["failure_reason"], `${fieldPath}.failure_reason`),
+    };
 }
-function optionalNumber(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+function parseMetadataOnlySessionReportRows(value, fieldPath) {
+    const sessions = requireArray(value, fieldPath).map((session, index) => {
+        const parsed = CodexSessionAttributionSchema.safeParse(session);
+        if (!parsed.success) {
+            invalidUploadSpoolState(`${fieldPath}[${index}]`, "metadata-only Codex session attribution");
+        }
+        return parsed.data;
+    });
+    if (sessions.length === 0) {
+        invalidUploadSpoolState(fieldPath, "non-empty array");
+    }
+    return sessions;
+}
+function parseRetrySource(value, fieldPath) {
+    if (value === "codex" || value === "claude_code")
+        return value;
+    return invalidUploadSpoolState(fieldPath, '"codex" or "claude_code"');
+}
+function mergeSessionReportRows(existing, incoming) {
+    const bySession = new Map();
+    for (const session of [...existing, ...incoming]) {
+        bySession.set(`${session.source ?? "codex"}:${session.codex_session_id}`, session);
+    }
+    return [...bySession.values()];
+}
+function firstPendingFailureReason(state) {
+    return (state.pending_uploads[0]?.failure_reason ??
+        state.pending_source_retries[0]?.reason ??
+        state.pending_session_reports[0]?.failure_reason ??
+        null);
+}
+function requireRecord(value, fieldPath) {
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+        return value;
+    }
+    return invalidUploadSpoolState(fieldPath, "object");
+}
+function requireArray(value, fieldPath) {
+    if (Array.isArray(value))
+        return value;
+    return invalidUploadSpoolState(fieldPath, "array");
+}
+function optionalArray(value, fieldPath) {
+    return value === undefined ? [] : requireArray(value, fieldPath);
+}
+function requireString(value, fieldPath) {
+    if (typeof value === "string" && value.trim())
+        return value;
+    return invalidUploadSpoolState(fieldPath, "non-empty string");
+}
+function requireNullableString(value, fieldPath) {
+    if (value === null)
+        return null;
+    return requireString(value, fieldPath);
+}
+function requireNonNegativeInteger(value, fieldPath) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0) {
+        return value;
+    }
+    return invalidUploadSpoolState(fieldPath, "non-negative integer");
+}
+function requireBoolean(value, fieldPath) {
+    if (typeof value === "boolean")
+        return value;
+    return invalidUploadSpoolState(fieldPath, "boolean");
+}
+function invalidUploadSpoolState(fieldPath, expected) {
+    throw new Error(`Upload spool state schema mismatch at ${fieldPath}; expected ${expected}.`);
+}
+function isErrnoException(error, code) {
+    return (error instanceof Error &&
+        "code" in error &&
+        error.code === code);
+}
+function uploadSpoolReadError(filePath, classification, cause) {
+    const detail = cause &&
+        typeof cause === "object" &&
+        "code" in cause &&
+        typeof cause.code === "string"
+        ? ` (${cause.code})`
+        : "";
+    return new Error(`Upload spool state at ${filePath} is ${classification}; refusing to treat pending delivery state as empty.${detail}`);
+}
+async function fsyncDirectoryBestEffort(directoryPath) {
+    let handle = null;
+    try {
+        handle = await fs.open(directoryPath, "r");
+        await handle.sync();
+    }
+    catch {
+        // Directory fsync is not supported by every host/filesystem (notably some
+        // Windows versions). The file itself was fsynced before the atomic rename.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
 }