@bli-cockpit/cli 0.2.4 → 0.2.7

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/install-event-outbox.js

@@ -0,0 +1,191 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import path from "node:path";
+const OUTBOX_DIRECTORY = "install-events";
+const MAX_PENDING_ENTRIES = 100;
+const MAX_EVENTS_PER_ENTRY = 40;
+export async function enqueueInstallEventEntry(paths, options) {
+    if (options.events.length === 0)
+        return null;
+    const createdAt = (options.now ?? new Date()).toISOString();
+    const entry = {
+        schema_version: "cockpit-install-event-outbox.v1",
+        outbox_id: `install-event-${crypto.randomUUID()}`,
+        created_at: createdAt,
+        last_attempt_at: null,
+        retry_count: 0,
+        last_failure_reason: null,
+        dashboard_url: options.dashboardUrl,
+        cli_version: options.cliVersion,
+        command: options.command,
+        os_platform: options.osPlatform,
+        events: options.events.slice(0, MAX_EVENTS_PER_ENTRY).map((event) => ({
+            step: event.step,
+            status: event.status,
+            ...(event.error_code ? { error_code: event.error_code } : {}),
+            at: event.at ?? createdAt,
+        })),
+    };
+    await writeEntry(paths, entry);
+    await pruneInstallEventOutbox(paths);
+    return entry;
+}
+export async function readPendingInstallEventEntries(paths) {
+    const directory = installEventOutboxDirectory(paths);
+    const names = await fs.readdir(directory).catch(() => []);
+    const entries = [];
+    for (const name of names.filter((candidate) => candidate.endsWith(".json"))) {
+        const filePath = path.join(directory, name);
+        try {
+            const parsed = parseEntry(JSON.parse(await fs.readFile(filePath, "utf8")));
+            if (!parsed) {
+                await fs.rm(filePath, { force: true });
+                continue;
+            }
+            entries.push(parsed);
+        }
+        catch {
+            await fs.rm(filePath, { force: true }).catch(() => undefined);
+        }
+    }
+    return entries.sort((left, right) => Date.parse(left.created_at) - Date.parse(right.created_at) ||
+        left.outbox_id.localeCompare(right.outbox_id));
+}
+export async function summarizeInstallEventOutbox(paths) {
+    const entries = await readPendingInstallEventEntries(paths);
+    const attempted = entries
+        .filter((entry) => entry.last_attempt_at)
+        .sort((left, right) => Date.parse(right.last_attempt_at) - Date.parse(left.last_attempt_at))[0];
+    return {
+        pending_count: entries.length,
+        oldest_created_at: entries[0]?.created_at ?? null,
+        last_attempt_at: attempted?.last_attempt_at ?? null,
+        last_failure_reason: attempted?.last_failure_reason ?? null,
+    };
+}
+export async function recordInstallEventAttemptFailure(paths, entry, options) {
+    await writeEntry(paths, {
+        ...entry,
+        last_attempt_at: options.attemptedAt,
+        retry_count: entry.retry_count + 1,
+        last_failure_reason: options.failureReason,
+    });
+}
+export async function removeInstallEventEntry(paths, outboxId) {
+    await fs.rm(entryPath(paths, outboxId), { force: true });
+}
+export function installEventOutboxDirectory(paths) {
+    return path.join(paths.spool_dir, OUTBOX_DIRECTORY);
+}
+async function pruneInstallEventOutbox(paths) {
+    const entries = await readPendingInstallEventEntries(paths);
+    const excess = entries.slice(0, Math.max(0, entries.length - MAX_PENDING_ENTRIES));
+    await Promise.all(excess.map((entry) => removeInstallEventEntry(paths, entry.outbox_id)));
+}
+async function writeEntry(paths, entry) {
+    const directory = installEventOutboxDirectory(paths);
+    const filePath = entryPath(paths, entry.outbox_id);
+    const tempPath = `${filePath}.tmp-${process.pid}-${crypto.randomUUID()}`;
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32") {
+        await fs.chmod(directory, 0o700).catch(() => undefined);
+    }
+    try {
+        await fs.writeFile(tempPath, `${JSON.stringify(entry, null, 2)}\n`, {
+            mode: 0o600,
+            flag: "wx",
+        });
+        await fs.rename(tempPath, filePath);
+        if (process.platform !== "win32") {
+            await fs.chmod(filePath, 0o600).catch(() => undefined);
+        }
+    }
+    finally {
+        await fs.rm(tempPath, { force: true }).catch(() => undefined);
+    }
+}
+function entryPath(paths, outboxId) {
+    return path.join(installEventOutboxDirectory(paths), `${safeOutboxId(outboxId)}.json`);
+}
+function safeOutboxId(value) {
+    return value.replace(/[^a-z0-9_-]/giu, "").slice(0, 120);
+}
+function parseEntry(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const command = installEventCommand(record["command"]);
+    const events = Array.isArray(record["events"])
+        ? record["events"].map(parseEvent).filter(isPresent)
+        : [];
+    if (record["schema_version"] !== "cockpit-install-event-outbox.v1" ||
+        !stringValue(record["outbox_id"]) ||
+        !stringValue(record["created_at"]) ||
+        !stringValue(record["dashboard_url"]) ||
+        !stringValue(record["cli_version"]) ||
+        !stringValue(record["os_platform"]) ||
+        !command ||
+        events.length === 0) {
+        return null;
+    }
+    return {
+        schema_version: "cockpit-install-event-outbox.v1",
+        outbox_id: stringValue(record["outbox_id"]),
+        created_at: stringValue(record["created_at"]),
+        last_attempt_at: stringValue(record["last_attempt_at"]),
+        retry_count: finiteNumber(record["retry_count"]),
+        last_failure_reason: stringValue(record["last_failure_reason"]),
+        dashboard_url: stringValue(record["dashboard_url"]),
+        cli_version: stringValue(record["cli_version"]),
+        command,
+        os_platform: stringValue(record["os_platform"]),
+        events: events.slice(0, MAX_EVENTS_PER_ENTRY),
+    };
+}
+function parseEvent(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const step = stringValue(record["step"]);
+    const status = installEventStatus(record["status"]);
+    const at = stringValue(record["at"]);
+    if (!step || !status || !at)
+        return null;
+    return {
+        step,
+        status,
+        ...(stringValue(record["error_code"])
+            ? { error_code: stringValue(record["error_code"]) }
+            : {}),
+        at,
+    };
+}
+function installEventCommand(value) {
+    return [
+        "onboard",
+        "update",
+        "install",
+        "login",
+        "sync",
+        "backfill",
+        "doctor",
+    ].includes(String(value))
+        ? value
+        : null;
+}
+function installEventStatus(value) {
+    return value === "ok" || value === "fail" || value === "skipped"
+        ? value
+        : null;
+}
+function stringValue(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function finiteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0
+        ? Math.floor(value)
+        : 0;
+}
+function isPresent(value) {
+    return value !== null;
+}