@bli-cockpit/cli 0.1.2 → 0.1.5

package/dist/evidence-upload-client.js

@@ -0,0 +1,362 @@
+import { RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES, RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN, } from "@bli-cockpit/telemetry-core";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+const DEFAULT_MAX_ATTEMPTS = 3;
+const RETRY_DELAY_MS = 250;
+export async function uploadRawEvidenceFilesChunked(options) {
+    const outcomes = [];
+    if (options.files.length === 0) {
+        return summarizeOutcomes(outcomes, false);
+    }
+    const chunkSizeBytes = options.chunkSizeBytes ?? RAW_EVIDENCE_UPLOAD_DEFAULT_CHUNK_BYTES;
+    const loaded = [];
+    const loadedByObjectKey = new Map();
+    for (const file of options.files) {
+        let bytes;
+        try {
+            bytes = await fs.readFile(file.local_path);
+        }
+        catch {
+            outcomes.push(failedOutcome(file, "file_read_failed"));
+            continue;
+        }
+        if (bytes.byteLength === 0) {
+            outcomes.push(failedOutcome(file, "empty_file"));
+            continue;
+        }
+        if (bytes.byteLength > RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
+            outcomes.push(failedOutcome(file, "file_too_large"));
+            continue;
+        }
+        // Content-addressed keys collide for byte-identical files (e.g. a resumed
+        // session copied twice); upload once and share the outcome instead of
+        // racing a second upload against a committed ledger row.
+        const existing = file.pointer.object_key
+            ? loadedByObjectKey.get(file.pointer.object_key)
+            : undefined;
+        if (existing) {
+            existing.duplicates.push(file);
+            continue;
+        }
+        const entry = {
+            file,
+            bytes,
+            chunkCount: Math.ceil(bytes.byteLength / chunkSizeBytes),
+            duplicates: [],
+        };
+        loaded.push(entry);
+        if (file.pointer.object_key) {
+            loadedByObjectKey.set(file.pointer.object_key, entry);
+        }
+    }
+    const resolvedEntries = new Set();
+    let beginUnavailable = false;
+    for (const batch of batches(loaded, RAW_EVIDENCE_UPLOAD_MAX_OBJECTS_PER_BEGIN)) {
+        if (beginUnavailable)
+            break;
+        const begin = await requestJson(options, "/api/ambient/evidence/upload/begin", {
+            schema_version: "ambient-raw-evidence-upload-begin.v1",
+            generated_at: options.generatedAt,
+            provenance: options.provenance,
+            objects: batch.map((entry) => ({
+                pointer: entry.file.pointer,
+                chunk_size_bytes: chunkSizeBytes,
+                chunk_count: entry.chunkCount,
+            })),
+        });
+        // 404 means an old dashboard without the chunk routes; a persistent 5xx
+        // (after retries) covers a new dashboard whose ledger migration has not
+        // been applied yet. Both still serve the legacy v1 route.
+        if (begin.status === 404 || begin.status >= 500) {
+            beginUnavailable = true;
+            break;
+        }
+        if (!begin.ok) {
+            for (const entry of batch) {
+                outcomes.push(failedOutcome(entry.file, `begin_failed_http_${begin.status}`));
+                for (const duplicate of entry.duplicates) {
+                    outcomes.push(failedOutcome(duplicate, `begin_failed_http_${begin.status}`));
+                }
+                resolvedEntries.add(entry);
+            }
+            continue;
+        }
+        const dispositions = readBeginDispositions(begin.body);
+        for (const entry of batch) {
+            const objectKey = entry.file.pointer.object_key ?? "";
+            const disposition = dispositions.get(objectKey);
+            if (!disposition) {
+                outcomes.push(failedOutcome(entry.file, "begin_missing_disposition"));
+                for (const duplicate of entry.duplicates) {
+                    outcomes.push(failedOutcome(duplicate, "begin_missing_disposition"));
+                }
+                resolvedEntries.add(entry);
+                continue;
+            }
+            const outcome = await uploadOneObject(options, entry, disposition, chunkSizeBytes);
+            outcomes.push(outcome);
+            for (const duplicate of entry.duplicates) {
+                outcomes.push(duplicateOutcome(outcome, duplicate));
+            }
+            resolvedEntries.add(entry);
+        }
+    }
+    if (beginUnavailable) {
+        return uploadWithLegacyFallback(options, loaded.filter((entry) => !resolvedEntries.has(entry)), outcomes);
+    }
+    return summarizeOutcomes(outcomes, false);
+}
+/**
+ * A duplicate file shares its primary's fate, but a primary that physically
+ * uploaded leaves the duplicate as reuse of now-durable content — counting it
+ * as a second upload would inflate object counts.
+ */
+function duplicateOutcome(primary, duplicate) {
+    return {
+        ...primary,
+        pointer: duplicate.pointer,
+        codex_session_id: duplicate.codex_session_id ?? null,
+        kind: duplicate.kind ?? "unknown",
+        upload_state: primary.upload_state === "uploaded"
+            ? "reused_existing"
+            : primary.upload_state,
+        reason: primary.upload_state === "uploaded" ? "duplicate_in_batch" : primary.reason,
+        uploaded_chunk_count: 0,
+    };
+}
+async function uploadOneObject(options, entry, disposition, chunkSizeBytes) {
+    const objectKey = entry.file.pointer.object_key ?? "";
+    if (disposition.disposition === "already_committed") {
+        return {
+            pointer: entry.file.pointer,
+            object_key: objectKey,
+            codex_session_id: entry.file.codex_session_id ?? null,
+            kind: entry.file.kind ?? "unknown",
+            upload_state: "reused_existing",
+            reason: "already_committed",
+            uploaded_chunk_count: 0,
+        };
+    }
+    if (disposition.disposition === "conflict" || !disposition.upload_id) {
+        return failedOutcome(entry.file, disposition.reason ?? "upload_conflict");
+    }
+    const received = new Set(disposition.received_chunk_indexes);
+    let uploadedChunks = 0;
+    for (let index = 0; index < entry.chunkCount; index += 1) {
+        if (received.has(index))
+            continue;
+        const chunk = entry.bytes.subarray(index * chunkSizeBytes, Math.min((index + 1) * chunkSizeBytes, entry.bytes.byteLength));
+        const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
+            schema_version: "ambient-raw-evidence-upload-chunk.v1",
+            generated_at: options.generatedAt,
+            provenance: options.provenance,
+            upload_id: disposition.upload_id,
+            object_key: objectKey,
+            chunk_index: index,
+            chunk_count: entry.chunkCount,
+            chunk_hash_sha256: sha256(chunk),
+            content_base64: chunk.toString("base64"),
+        });
+        if (!chunkResponse.ok) {
+            return failedOutcome(entry.file, `chunk_${index}_failed_http_${chunkResponse.status}`, uploadedChunks);
+        }
+        uploadedChunks += 1;
+    }
+    const commit = await requestJson(options, "/api/ambient/evidence/upload/commit", {
+        schema_version: "ambient-raw-evidence-upload-commit.v1",
+        generated_at: options.generatedAt,
+        provenance: options.provenance,
+        upload_id: disposition.upload_id,
+        object_key: objectKey,
+    });
+    if (!commit.ok) {
+        return failedOutcome(entry.file, `commit_failed_http_${commit.status}`, uploadedChunks);
+    }
+    // "already_committed" means a concurrent or earlier sync made these bytes
+    // durable; this sync does not own them, so they must be reported as reuse —
+    // a later ingest failure here must not clean up an object another sync's
+    // indexed refs already point at.
+    const commitStatus = commit.body && typeof commit.body === "object"
+        ? commit.body.status
+        : undefined;
+    if (commitStatus === "already_committed") {
+        return {
+            pointer: entry.file.pointer,
+            object_key: objectKey,
+            codex_session_id: entry.file.codex_session_id ?? null,
+            kind: entry.file.kind ?? "unknown",
+            upload_state: "reused_existing",
+            reason: "already_committed",
+            uploaded_chunk_count: uploadedChunks,
+        };
+    }
+    return {
+        pointer: entry.file.pointer,
+        object_key: objectKey,
+        codex_session_id: entry.file.codex_session_id ?? null,
+        kind: entry.file.kind ?? "unknown",
+        upload_state: "uploaded",
+        reason: null,
+        uploaded_chunk_count: uploadedChunks,
+    };
+}
+/**
+ * Older dashboards predate the chunk endpoints. Fall back to one legacy
+ * request per file so an oversized or already-existing object fails (or
+ * reuses) individually instead of dragging the whole batch down. Large files
+ * are attempted rather than pre-failed: a non-serverless dashboard (the
+ * default localhost deployment) accepts them like the old CLI could, and a
+ * platform body-limit rejection comes back as a labeled per-file failure.
+ */
+async function uploadWithLegacyFallback(options, loaded, outcomes) {
+    for (const entry of loaded) {
+        let outcome;
+        const response = await requestJson(options, "/api/ambient/evidence/upload", {
+            schema_version: "ambient-raw-evidence-upload.v1",
+            generated_at: options.generatedAt,
+            provenance: options.provenance,
+            files: [
+                {
+                    pointer: entry.file.pointer,
+                    content_base64: entry.bytes.toString("base64"),
+                },
+            ],
+        });
+        if (response.ok) {
+            outcome = {
+                pointer: entry.file.pointer,
+                object_key: entry.file.pointer.object_key ?? "",
+                codex_session_id: entry.file.codex_session_id ?? null,
+                kind: entry.file.kind ?? "unknown",
+                upload_state: "uploaded",
+                reason: "legacy_single_shot_upload",
+                uploaded_chunk_count: 1,
+            };
+        }
+        else if (response.status === 409) {
+            // Content-addressed keys repeat across syncs; the legacy route reports
+            // an existing object as a duplicate, which means the bytes are durable.
+            outcome = {
+                pointer: entry.file.pointer,
+                object_key: entry.file.pointer.object_key ?? "",
+                codex_session_id: entry.file.codex_session_id ?? null,
+                kind: entry.file.kind ?? "unknown",
+                upload_state: "reused_existing",
+                reason: "legacy_already_exists",
+                uploaded_chunk_count: 0,
+            };
+        }
+        else {
+            outcome = failedOutcome(entry.file, `legacy_upload_failed_http_${response.status}`);
+        }
+        outcomes.push(outcome);
+        for (const duplicate of entry.duplicates) {
+            outcomes.push(duplicateOutcome(outcome, duplicate));
+        }
+    }
+    return summarizeOutcomes(outcomes, true);
+}
+async function requestJson(options, routePath, body) {
+    const maxAttempts = options.maxAttemptsPerRequest ?? DEFAULT_MAX_ATTEMPTS;
+    const sleep = options.sleep ?? defaultSleep;
+    let lastStatus = 0;
+    let lastBody = null;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            const response = await options.fetchImpl(`${options.dashboardUrl}${routePath}`, {
+                method: "POST",
+                headers: {
+                    "Authorization": `Bearer ${options.deviceToken}`,
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(body),
+            });
+            lastStatus = response.status;
+            lastBody = await readResponseJson(response);
+            if (response.ok || (response.status < 500 && response.status !== 429)) {
+                return { ok: response.ok, status: response.status, body: lastBody };
+            }
+        }
+        catch {
+            lastStatus = 0;
+            lastBody = null;
+        }
+        if (attempt < maxAttempts)
+            await sleep(RETRY_DELAY_MS * attempt);
+    }
+    return { ok: false, status: lastStatus, body: lastBody };
+}
+function readBeginDispositions(body) {
+    const map = new Map();
+    if (!body || typeof body !== "object")
+        return map;
+    const objects = body.objects;
+    if (!Array.isArray(objects))
+        return map;
+    for (const entry of objects) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const record = entry;
+        const objectKey = record["object_key"];
+        const disposition = record["disposition"];
+        if (typeof objectKey !== "string" || typeof disposition !== "string") {
+            continue;
+        }
+        map.set(objectKey, {
+            disposition,
+            upload_id: typeof record["upload_id"] === "string" ? record["upload_id"] : null,
+            received_chunk_indexes: Array.isArray(record["received_chunk_indexes"])
+                ? record["received_chunk_indexes"].filter((value) => typeof value === "number")
+                : [],
+            reason: typeof record["reason"] === "string" ? record["reason"] : null,
+        });
+    }
+    return map;
+}
+function failedOutcome(file, reason, uploadedChunks = 0) {
+    return {
+        pointer: file.pointer,
+        object_key: file.pointer.object_key ?? "",
+        codex_session_id: file.codex_session_id ?? null,
+        kind: file.kind ?? "unknown",
+        upload_state: "upload_failed",
+        reason,
+        uploaded_chunk_count: uploadedChunks,
+    };
+}
+function summarizeOutcomes(outcomes, usedLegacyFallback) {
+    const uploaded = outcomes.filter((outcome) => outcome.upload_state === "uploaded");
+    return {
+        outcomes,
+        uploaded_object_keys: uploaded.map((outcome) => outcome.object_key),
+        uploaded_object_count: uploaded.length,
+        uploaded_chunk_count: outcomes.reduce((sum, outcome) => sum + outcome.uploaded_chunk_count, 0),
+        reused_count: outcomes.filter((outcome) => outcome.upload_state === "reused_existing").length,
+        failed_count: outcomes.filter((outcome) => outcome.upload_state === "upload_failed").length,
+        used_legacy_fallback: usedLegacyFallback,
+    };
+}
+async function readResponseJson(response) {
+    const text = await response.text();
+    if (!text)
+        return {};
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { message: text };
+    }
+}
+function batches(items, size) {
+    const out = [];
+    for (let offset = 0; offset < items.length; offset += size) {
+        out.push(items.slice(offset, offset + size));
+    }
+    return out;
+}
+function defaultSleep(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}

package/dist/local-state.js

@@ -3,14 +3,16 @@ import crypto from "node:crypto";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { resolveRepoWorktreeIdentity, } from "./repo-identity.js";
 import { summarizeLocalUploadSpool } from "./spool/local-spool.js";
-export const LOCAL_COLLECTOR_VERSION = "0.1.2";
+export const LOCAL_COLLECTOR_VERSION = "0.1.5";
 export const DEFAULT_DASHBOARD_URL = "http://127.0.0.1:3100";
 export function getCollectorRuntimePaths(homeDir = os.homedir()) {
     const paths = getUserLocalCockpitPaths(homeDir);
     return {
         ...paths,
         active_work_context_file: path.join(paths.state_dir, "active-work-context.json"),
+        work_contexts_dir: path.join(paths.state_dir, "work-contexts"),
     };
 }
 export async function installLocalCollector(options = {}) {
@@ -119,16 +121,24 @@ export async function startLocalWorkContext(options = {}) {
     const repoRoot = path.resolve(options.repoRoot ?? process.cwd());
     const paths = getCollectorRuntimePaths(homeDir);
     await ensureRuntimeDirectories(paths);
+    const config = await readLocalCollectorConfig(paths).catch(() => null);
     const session = await readLocalSessionReference(paths, {
         operatorId: options.operatorId,
         sessionId: options.sessionId,
     });
-    const branch = options.branch ?? (await resolveGitBranch(repoRoot));
-    const existingContext = await readLocalWorkContext(paths).catch(() => null);
-    const workContextId = existingContext?.work_context_id ?? `work-${crypto.randomUUID()}`;
+    const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
+    const branch = options.branch ?? identity.branch;
     const sessionId = options.sessionId ??
         (session.session_state === "missing" ? `local-${crypto.randomUUID()}` : session.session_id);
     const operatorId = options.operatorId ?? session.operator_id;
+    const deviceId = session.device_id ?? config?.device_id ?? "device-unknown";
+    const workContextId = stableWorkContextId({
+        operatorId,
+        deviceId,
+        repoFingerprint: identity.repo_fingerprint,
+        worktreeFingerprint: identity.worktree_fingerprint,
+    });
+    const existingContext = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
     const ticketBindingCandidates = options.activeTicketId
         ? [
             {
@@ -141,8 +151,15 @@ export async function startLocalWorkContext(options = {}) {
         : [];
     const context = LocalWorkContextSchema.parse({
         work_context_id: workContextId,
-        repo: repoRoot,
+        repo: identity.repo_root,
         branch,
+        repo_label: identity.repo_label,
+        repo_fingerprint: identity.repo_fingerprint,
+        repo_origin_url: identity.repo_origin_url ?? undefined,
+        head_sha: identity.head_sha ?? undefined,
+        worktree_label: identity.worktree_label,
+        worktree_fingerprint: identity.worktree_fingerprint,
+        worktree_is_primary: identity.worktree_is_primary,
         operator_id: operatorId,
         session_id: sessionId,
         started_at: existingContext?.started_at ?? now.toISOString(),
@@ -154,13 +171,20 @@ export async function startLocalWorkContext(options = {}) {
             capture_source: "collector_runtime",
             capture_adapter_version: LOCAL_COLLECTOR_VERSION,
             collector_version: LOCAL_COLLECTOR_VERSION,
-            repo: repoRoot,
+            repo: identity.repo_root,
             branch,
+            repo_label: identity.repo_label,
+            repo_fingerprint: identity.repo_fingerprint,
+            repo_origin_url: identity.repo_origin_url ?? undefined,
+            worktree_label: identity.worktree_label,
+            worktree_fingerprint: identity.worktree_fingerprint,
+            worktree_is_primary: identity.worktree_is_primary,
             operator_id: operatorId,
             session_id: sessionId,
             work_context_id: workContextId,
         },
     });
+    await writeJsonFile(workContextFile(paths, identity.worktree_fingerprint), context);
     await writeJsonFile(paths.active_work_context_file, context);
     return context;
 }
@@ -174,8 +198,9 @@ export async function inspectLocalCollectorStatus(options = {}) {
         operatorId: options.operatorId,
         sessionId: options.sessionId,
     });
-    const context = await readLocalWorkContext(paths).catch(() => null);
-    const branch = options.branch ?? (await resolveGitBranch(repoRoot));
+    const identity = await resolveIdentityOrFallback(repoRoot, options.branch);
+    const context = await readLocalWorkContextForRepo(paths, repoRoot).catch(() => null);
+    const branch = options.branch ?? identity.branch;
     const freshness = classifyCollectorFreshness(context, now);
     const uploadSpool = await summarizeLocalUploadSpool(paths);
     const uploadState = !config
@@ -212,10 +237,15 @@ export async function inspectLocalCollectorStatus(options = {}) {
         config_file: paths.config_file,
         session_file: paths.session_file,
         session_state: session.session_state,
-        repo: repoRoot,
+        repo: context?.repo ?? identity.repo_root,
         branch,
         active_ticket_id: context?.active_ticket_id ?? null,
         work_context_id: context?.work_context_id ?? null,
+        repo_label: context?.repo_label ?? identity.repo_label,
+        repo_fingerprint: context?.repo_fingerprint ?? identity.repo_fingerprint,
+        worktree_label: context?.worktree_label ?? identity.worktree_label,
+        worktree_fingerprint: context?.worktree_fingerprint ?? identity.worktree_fingerprint,
+        worktree_is_primary: context?.worktree_is_primary ?? identity.worktree_is_primary,
         collector_freshness: freshness,
         upload_state: uploadState,
         last_upload_attempt_at: uploadSpool.last_upload_attempt_at,
@@ -232,6 +262,21 @@ export async function readLocalCollectorConfig(paths) {
 export async function readLocalWorkContext(paths) {
     return LocalWorkContextSchema.parse(await readJsonFile(paths.active_work_context_file));
 }
+export async function readLocalWorkContextForRepo(paths, repoRoot) {
+    const identity = await resolveIdentityOrFallback(repoRoot);
+    const context = await readLocalWorkContextByFingerprint(paths, identity.worktree_fingerprint).catch(() => null);
+    if (context)
+        return context;
+    const active = await readLocalWorkContext(paths);
+    if (active.worktree_fingerprint === identity.worktree_fingerprint ||
+        path.resolve(active.repo) === identity.repo_root) {
+        return active;
+    }
+    throw new Error(`Active work context missing for ${identity.worktree_label}. Run \`cockpit start --repo "${identity.repo_root}"\`.`);
+}
+async function readLocalWorkContextByFingerprint(paths, worktreeFingerprint) {
+    return LocalWorkContextSchema.parse(await readJsonFile(workContextFile(paths, worktreeFingerprint)));
+}
 export async function readLocalSessionReference(paths, fallback = {}) {
     try {
         const rawSession = await readJsonFile(paths.session_file);
@@ -284,15 +329,54 @@ async function ensureRuntimeDirectories(paths) {
     await fs.mkdir(paths.state_dir, { recursive: true, mode: 0o700 });
     await fs.mkdir(paths.spool_dir, { recursive: true, mode: 0o700 });
     await fs.mkdir(paths.cursors_dir, { recursive: true, mode: 0o700 });
+    await fs.mkdir(paths.work_contexts_dir, { recursive: true, mode: 0o700 });
     if (process.platform !== "win32") {
         await Promise.all([
             fs.chmod(paths.config_dir, 0o700).catch(() => undefined),
             fs.chmod(paths.state_dir, 0o700).catch(() => undefined),
             fs.chmod(paths.spool_dir, 0o700).catch(() => undefined),
             fs.chmod(paths.cursors_dir, 0o700).catch(() => undefined),
+            fs.chmod(paths.work_contexts_dir, 0o700).catch(() => undefined),
         ]);
     }
 }
+function workContextFile(paths, worktreeFingerprint) {
+    return path.join(paths.work_contexts_dir, `${worktreeFingerprint}.json`);
+}
+async function resolveIdentityOrFallback(repoRoot, branchOverride) {
+    const resolvedRoot = path.resolve(repoRoot);
+    const identity = await resolveRepoWorktreeIdentity(resolvedRoot).catch(() => null);
+    if (identity) {
+        return branchOverride ? { ...identity, branch: branchOverride } : identity;
+    }
+    const repoLabel = path.basename(resolvedRoot) || "workspace";
+    const repoFingerprint = `repo-${sha256(`local:${resolvedRoot}`).slice(0, 24)}`;
+    const worktreeFingerprint = `wt-${sha256(`${repoFingerprint}:${resolvedRoot}`).slice(0, 24)}`;
+    const branch = branchOverride ?? (await resolveGitBranch(resolvedRoot));
+    return {
+        requested_path: resolvedRoot,
+        repo_root: resolvedRoot,
+        repo_label: repoLabel,
+        repo_fingerprint: repoFingerprint,
+        repo_origin_url: null,
+        branch,
+        head_sha: null,
+        worktree_label: repoLabel,
+        worktree_fingerprint: worktreeFingerprint,
+        worktree_is_primary: true,
+    };
+}
+function stableWorkContextId(input) {
+    return `work-${sha256([
+        input.operatorId,
+        input.deviceId,
+        input.repoFingerprint,
+        input.worktreeFingerprint,
+    ].join(":")).slice(0, 32)}`;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value, "utf8").digest("hex");
+}
 async function readJsonFile(filePath) {
     return JSON.parse(await fs.readFile(filePath, "utf8"));
 }