@bli-cockpit/cli 0.1.33 → 0.2.1

package/dist/local-state.js

@@ -106,7 +106,7 @@ export async function pairLocalCollector(options = {}) {
         device_name: deviceName,
         claimed_owner_email: claimedOwnerEmail,
         collector_version: LOCAL_COLLECTOR_VERSION,
-    });
+    }, options.pairingAccessToken);
     options.onPairStarted?.(startResponse);
     const sessionFile = await pollPairRequest(fetchImpl, dashboardUrl, {
         paths,
@@ -459,10 +459,13 @@ function normalizeDashboardUrl(value) {
         throw new Error("Dashboard URL cannot be empty.");
     return normalized;
 }
-async function postPairStart(fetchImpl, dashboardUrl, body) {
+async function postPairStart(fetchImpl, dashboardUrl, body, accessToken) {
     const response = await fetchImpl(`${dashboardUrl}/api/ambient/pair/start`, {
         method: "POST",
-        headers: { "Content-Type": "application/json" },
+        headers: {
+            "Content-Type": "application/json",
+            ...(accessToken ? { "Authorization": `Bearer ${accessToken}` } : {}),
+        },
         body: JSON.stringify(body),
     });
     const parsed = await readResponseJson(response);

package/dist/onboarding-roots.js

@@ -1,67 +1,101 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { discoverGitWorktrees } from "./repo-identity.js";
 import { normalizeCollectionRoots } from "./root-normalization.js";
 export const COLLECTION_ROOT_REQUIRED = "collection_root_required";
+export const HOME_ROOT_CONSENT_PROMPT = "Collect your ENTIRE home folder? Any git repo you ever create under it will be collected automatically. Type 'everything' to confirm: ";
 export async function resolveOnboardingRoots(options) {
-    const explicitRoots = normalizeRoots(options.explicitRoots ?? []);
-    if (explicitRoots.length > 0) {
-        return { roots: explicitRoots, source: "explicit", confirmed: true };
+    const explicitInput = options.explicitRoots ?? [];
+    const explicit = normalizeRootsDetailed(explicitInput, {
+        homeDir: options.homeDir,
+        allowHomeRoot: options.allowHomeRoot,
+    });
+    if (explicit.roots.length > 0) {
+        explainRejectedRoots(options, explicit.rejected);
+        return resolvedRoots(options, explicit.roots, "explicit", true);
     }
-    const savedRoots = normalizeRoots([
+    if (hasRootInput(explicitInput) && explicit.rejected.length > 0) {
+        if (!options.interactive) {
+            throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${rootRejectionExplanation(explicit.rejected[0], options)}`);
+        }
+        explainRejectedRoots(options, explicit.rejected);
+        const homeOffer = await counterOfferHomeDirectoryRepos(options, explicit.rejected);
+        if (homeOffer)
+            return homeOffer;
+        const homeOptIn = await promptForHomeRootOptIn(options, explicit.rejected);
+        if (homeOptIn)
+            return homeOptIn;
+        return promptForRoots(options, "Collection root(s), comma-separated: ");
+    }
+    const savedRoots = normalizeRootsDetailed([
         ...(options.savedRoots ?? []),
         ...(options.config?.default_repo_paths ?? []),
-    ]);
+    ], {
+        homeDir: options.homeDir,
+        allowHomeRoot: options.allowHomeRoot,
+    }).roots;
     if (savedRoots.length > 0) {
         if (!options.interactive) {
-            return { roots: savedRoots, source: "saved", confirmed: false };
+            return resolvedRoots(options, savedRoots, "saved", false);
         }
         const confirmed = await requirePrompt(options).confirm(savedRootsPrompt(savedRoots));
         if (confirmed) {
-            return { roots: savedRoots, source: "saved", confirmed: true };
+            return resolvedRoots(options, savedRoots, "saved", 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.`);
+        throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(options)}`);
     }
     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 };
+            return resolvedRoots(options, [cwdRoot], "cwd_likely_root", 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 resolvedRoots(options, [path.resolve(homeRoot)], "home_likely_root", true);
         }
     }
     return promptForRoots(options, "Collection root(s), comma-separated: ");
 }
 export function normalizeRoots(roots) {
+    return normalizeRootsDetailed(roots).roots;
+}
+export function normalizeRootsDetailed(roots, options = {}) {
     const seen = new Set();
     const candidates = [];
+    const rejected = [];
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
     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())
+            if (resolved === path.parse(resolved).root) {
+                rejected.push({ input: candidate, reason: "fs_root" });
                 continue;
+            }
+            if (resolved === homeDir) {
+                if (!options.allowHomeRoot) {
+                    rejected.push({ input: candidate, reason: "home_dir" });
+                    continue;
+                }
+            }
             if (seen.has(resolved))
                 continue;
             seen.add(resolved);
             candidates.push(resolved);
         }
     }
-    return normalizeCollectionRoots(candidates);
+    return { roots: normalizeCollectionRoots(candidates), rejected };
 }
 function splitRootInput(value) {
     return value
@@ -71,11 +105,29 @@ function splitRootInput(value) {
 }
 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>.`);
+    for (let attempt = 1; attempt <= 3; attempt += 1) {
+        const detailed = normalizeRootsDetailed([await prompt.input(message)], {
+            homeDir: options.homeDir,
+            allowHomeRoot: options.allowHomeRoot,
+        });
+        if (detailed.roots.length > 0) {
+            explainRejectedRoots(options, detailed.rejected);
+            return resolvedRoots(options, detailed.roots, "prompt", true);
+        }
+        if (detailed.rejected.length > 0) {
+            explainRejectedRoots(options, detailed.rejected);
+            const homeOffer = await counterOfferHomeDirectoryRepos(options, detailed.rejected);
+            if (homeOffer)
+                return homeOffer;
+            const homeOptIn = await promptForHomeRootOptIn(options, detailed.rejected);
+            if (homeOptIn)
+                return homeOptIn;
+        }
+        else {
+            prompt.message?.(missingCollectionRootMessage(options));
+        }
     }
-    return { roots, source: "prompt", confirmed: true };
+    throw new Error(`${COLLECTION_ROOT_REQUIRED}: ${missingCollectionRootMessage(options)}`);
 }
 function savedRootsPrompt(roots) {
     if (roots.length === 1) {
@@ -93,6 +145,119 @@ function requirePrompt(options) {
     }
     return options.prompt;
 }
+function hasRootInput(inputs) {
+    return inputs.some((input) => input.trim().length > 0);
+}
+function explainRejectedRoots(options, rejections) {
+    if (!options.interactive || rejections.length === 0)
+        return;
+    const prompt = requirePrompt(options);
+    for (const rejection of rejections) {
+        prompt.message?.(rootRejectionPromptHint(rejection, options));
+    }
+}
+export function rootRejectionExplanation(rejection, options = {}) {
+    switch (rejection.reason) {
+        case "home_dir":
+            return homeRootTutorial(options.homeDir);
+        case "fs_root":
+            return filesystemRootTutorial(options.homeDir);
+    }
+}
+function rootRejectionPromptHint(rejection, options = {}) {
+    switch (rejection.reason) {
+        case "home_dir":
+            return homeRootTutorial(options.homeDir);
+        case "fs_root":
+            return filesystemRootTutorial(options.homeDir);
+    }
+}
+async function counterOfferHomeDirectoryRepos(options, rejections) {
+    const homeRejection = rejections.find((rejection) => rejection.reason === "home_dir");
+    if (!homeRejection)
+        return null;
+    const prompt = requirePrompt(options);
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    const discover = options.discoverGitWorktrees ?? discoverGitWorktrees;
+    const worktrees = await discover(homeDir, {
+        maxDepth: 3,
+        maxWorktrees: 50,
+    }).catch(() => []);
+    const roots = normalizeCollectionRoots([...new Set(worktrees.map((worktree) => path.resolve(worktree.repo_root)))]);
+    if (roots.length === 0)
+        return null;
+    const confirmed = await prompt.confirm([
+        "Your home folder can't be a collection root by default:",
+        `  I found ${roots.length} git repos under ${homeDir} that are safer to collect.`,
+        "Discovered repos:",
+        ...roots.map((root) => `- ${root}`),
+        "What you can do:",
+        "  1) Use these repos: answer y",
+        "  2) Pick different folders: answer n, then paste specific paths",
+        "  3) Collect everything anyway: answer n, then type everything at the next prompt",
+        "Collect from these? [Y/n] ",
+    ].join("\n"));
+    return confirmed ? resolvedRoots(options, roots, "prompt", true) : null;
+}
+async function promptForHomeRootOptIn(options, rejections) {
+    if (!rejections.some((rejection) => rejection.reason === "home_dir"))
+        return null;
+    const answer = await requirePrompt(options).input(HOME_ROOT_CONSENT_PROMPT);
+    if (answer.trim().toLowerCase() !== "everything")
+        return null;
+    return {
+        roots: [path.resolve(options.homeDir ?? os.homedir())],
+        source: "prompt",
+        confirmed: true,
+        homeRootOptIn: true,
+    };
+}
+function resolvedRoots(options, roots, source, confirmed) {
+    const result = { roots, source, confirmed };
+    if (options.allowHomeRoot && roots.some((root) => isHomeRoot(root, options.homeDir))) {
+        result.homeRootOptIn = true;
+    }
+    return result;
+}
+function isHomeRoot(root, homeDir) {
+    return path.resolve(root) === path.resolve(homeDir ?? os.homedir());
+}
+function homeRootTutorial(homeDirInput) {
+    const homeDir = path.resolve(homeDirInput ?? os.homedir());
+    const bliRoot = path.join(homeDir, "BLI");
+    const otherRoot = path.join(homeDir, "other");
+    return [
+        "Your home folder can't be a collection root by default:",
+        `  scanning all of ${homeDir} would include personal folders and every repo you ever create.`,
+        "What you can do:",
+        `  1) Specific folders: cockpit onboard --workspace "${bliRoot},${otherRoot}"`,
+        "  2) One work parent: mkdir ~/BLI && move your repos in, then: cockpit onboard --workspace ~/BLI",
+        "  3) Collect everything anyway (company machine): rerun with --allow-home-root",
+    ].join("\n");
+}
+function filesystemRootTutorial(homeDirInput) {
+    const homeDir = path.resolve(homeDirInput ?? os.homedir());
+    const bliRoot = path.join(homeDir, "BLI");
+    const otherRoot = path.join(homeDir, "other");
+    return [
+        "Your filesystem root can't be a collection root:",
+        `  scanning all of ${path.parse(homeDir).root} would include system folders, private data, and every mounted repo.`,
+        "What you can do:",
+        `  1) Specific folders: cockpit onboard --workspace "${bliRoot},${otherRoot}"`,
+        "  2) One work parent: mkdir ~/BLI && move your repos in, then: cockpit onboard --workspace ~/BLI",
+    ].join("\n");
+}
+export function missingCollectionRootMessage(options = {}) {
+    const homeDir = path.resolve(options.homeDir ?? os.homedir());
+    return [
+        "No collection root was confirmed:",
+        "  Cockpit only scans folders you name or confirm.",
+        "What you can do:",
+        `  1) Paste one work parent: ${path.join(homeDir, "BLI")}`,
+        `  2) Paste specific folders: ${path.join(homeDir, "repo-a")},${path.join(homeDir, "repo-b")}`,
+        "  3) Stop and rerun with a flag: cockpit onboard --workspace ~/BLI",
+    ].join("\n");
+}
 function likelyBliRootFromCwd(cwd) {
     const parts = cwd.split(path.sep).filter(Boolean);
     const index = parts.lastIndexOf("BLI");

package/dist/raw-evidence-gc.js

@@ -0,0 +1,122 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { readRawEvidenceCursor } from "./cursors/raw-evidence-cursor.js";
+const RAW_EVIDENCE_RETENTION_MS = 7 * 24 * 60 * 60 * 1000;
+const SYNC_LOG_MAX_BYTES = 50 * 1024 * 1024;
+// GC hashes every file in every old-but-kept dir to confirm uploads. Running
+// that on each 15-min sync would re-read the same gigabytes ~96x/day on
+// machines with unconfirmed evidence, so GC is throttled to once per day.
+const GC_MIN_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export async function runRawEvidenceLocalGc(paths, env = process.env, now = new Date()) {
+    if (env["COCKPIT_DISABLE_GC"] === "1") {
+        return {
+            skipped: true,
+            removed_dirs: 0,
+            freed_bytes: 0,
+            rotated_sync_log: false,
+        };
+    }
+    const throttleMarker = path.join(paths.state_dir, ".last-raw-evidence-gc");
+    const lastRun = await fs.stat(throttleMarker).catch(() => null);
+    if (lastRun && now.getTime() - lastRun.mtimeMs < GC_MIN_INTERVAL_MS) {
+        return {
+            skipped: true,
+            removed_dirs: 0,
+            freed_bytes: 0,
+            rotated_sync_log: false,
+        };
+    }
+    await fs.mkdir(paths.state_dir, { recursive: true }).catch(() => undefined);
+    await fs.writeFile(throttleMarker, now.toISOString()).catch(() => undefined);
+    const cursor = await readRawEvidenceCursor(paths);
+    const uploadedHashes = new Set(Object.keys(cursor.objects));
+    const rawEvidenceRoot = path.join(paths.state_dir, "raw-evidence");
+    const entries = await fs.readdir(rawEvidenceRoot, { withFileTypes: true }).catch(() => []);
+    let removedDirs = 0;
+    let freedBytes = 0;
+    for (const entry of entries) {
+        if (!entry.isDirectory() || !entry.name.startsWith("work-"))
+            continue;
+        const dir = path.join(rawEvidenceRoot, entry.name);
+        const dirStats = await fs.stat(dir).catch(() => null);
+        if (!dirStats?.isDirectory())
+            continue;
+        if (now.getTime() - dirStats.mtimeMs < RAW_EVIDENCE_RETENTION_MS)
+            continue;
+        const inspection = await inspectRawEvidenceDirForGc(dir, uploadedHashes);
+        if (!inspection.deletable)
+            continue;
+        await fs.rm(dir, { recursive: true, force: true }).catch(() => undefined);
+        if (await exists(dir))
+            continue;
+        removedDirs += 1;
+        freedBytes += inspection.byteSize;
+    }
+    return {
+        skipped: false,
+        removed_dirs: removedDirs,
+        freed_bytes: freedBytes,
+        rotated_sync_log: await rotateSyncLog(paths),
+    };
+}
+export function rawEvidenceGcSummary(result) {
+    return `raw-evidence GC: removed ${result.removed_dirs} dirs, freed ~${formatMb(result.freed_bytes)} MB`;
+}
+async function inspectRawEvidenceDirForGc(dir, uploadedHashes) {
+    const files = await listFiles(dir).catch(() => null);
+    if (!files)
+        return { deletable: false, byteSize: 0 };
+    if (files.length === 0)
+        return { deletable: true, byteSize: 0 };
+    let byteSize = 0;
+    for (const file of files) {
+        const bytes = await fs.readFile(file).catch(() => null);
+        if (!bytes)
+            return { deletable: false, byteSize: 0 };
+        const digest = crypto.createHash("sha256").update(bytes).digest("hex");
+        if (!uploadedHashes.has(digest)) {
+            return { deletable: false, byteSize: 0 };
+        }
+        byteSize += bytes.byteLength;
+    }
+    return { deletable: true, byteSize };
+}
+async function listFiles(root) {
+    const files = [];
+    const stack = [root];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        const entries = await fs.readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            const full = path.join(current, entry.name);
+            if (entry.isDirectory()) {
+                stack.push(full);
+            }
+            else if (entry.isFile()) {
+                files.push(full);
+            }
+            else {
+                throw new Error("raw-evidence directory contains unsupported entry");
+            }
+        }
+    }
+    return files;
+}
+async function rotateSyncLog(paths) {
+    const syncLog = path.join(paths.state_dir, "sync.log");
+    const info = await fs.stat(syncLog).catch(() => null);
+    if (!info?.isFile() || info.size <= SYNC_LOG_MAX_BYTES)
+        return false;
+    await fs.truncate(syncLog, 0).catch(() => undefined);
+    const after = await fs.stat(syncLog).catch(() => null);
+    return after?.isFile() === true && after.size === 0;
+}
+async function exists(target) {
+    return fs.stat(target).then(() => true, () => false);
+}
+function formatMb(bytes) {
+    return (bytes / (1024 * 1024)).toFixed(2);
+}

package/package.json

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