iteration-cli 0.9.0 → 0.10.0

package/dist/storage.js

@@ -1,809 +0,0 @@
-import { once } from "node:events";
-import { createReadStream, createWriteStream, promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { createInterface } from "node:readline";
-import { MAX_TRACE_EVENTS_PER_BATCH, parseTraceEventBatch, } from "iteration-trace-contracts";
-import * as z from "zod";
-import { redactTraceEvent } from "./redact-trace.js";
-const MAX_OUTBOX_BYTES = 64 * 1024 * 1024;
-export function collectorSource(config) {
-    return "cursorHome" in config
-        ? "cursor"
-        : "claudeHome" in config
-            ? "claude"
-            : "codex";
-}
-export function collectorSourceDirectory(config) {
-    return "cursorHome" in config
-        ? config.cursorHome
-        : "claudeHome" in config
-            ? config.claudeHome
-            : config.codexHome;
-}
-const connectionSchema = {
-    endpoint: z.string(),
-    token: z.string(),
-    dataDirectory: z.string(),
-    organizationId: z.uuid().optional(),
-    organizationName: z.string().min(1).max(160).optional(),
-};
-const configSchema = z.union([
-    z.object({ ...connectionSchema, codexHome: z.string() }).strict(),
-    z
-        .object({
-        ...connectionSchema,
-        source: z.literal("claude"),
-        claudeHome: z.string(),
-    })
-        .strict(),
-    z
-        .object({
-        ...connectionSchema,
-        source: z.literal("cursor"),
-        cursorHome: z.string(),
-    })
-        .strict(),
-]);
-const stateSchema = z
-    .object({
-    cursors: z.record(z.string(), z.number().int().min(0).max(Number.MAX_SAFE_INTEGER)),
-    skipping: z.array(z.string()),
-    sourceDirectory: z.string().nullable(),
-    initialized: z.boolean(),
-})
-    .strict();
-const healthSchema = z
-    .object({
-    lastUploadAtMs: z.number().int().min(0).nullable(),
-    historyCaughtUpAtMs: z.number().int().min(0).nullable(),
-    lastFailure: z
-        .object({
-        atMs: z.number().int().min(0),
-        kind: z.enum(["http", "network", "response", "collector"]),
-        status: z.number().int().min(100).max(599).nullable(),
-    })
-        .strict()
-        .nullable(),
-})
-    .strict();
-const redactionMarkerSchema = z.object({ version: z.literal(1) }).strict();
-function parseOutboxEvent(line) {
-    let decoded;
-    try {
-        decoded = JSON.parse(line);
-    }
-    catch (error) {
-        throw new Error("Trace outbox contains a malformed record.", {
-            cause: error,
-        });
-    }
-    const parsed = parseTraceEventBatch({ events: [decoded] });
-    if (!parsed.success)
-        throw new Error(`Trace outbox event is invalid: ${parsed.error}`);
-    const [event] = parsed.value.events;
-    if (event === undefined)
-        throw new Error("Trace outbox event is missing.");
-    return event;
-}
-export function defaultCollectorDirectory(source) {
-    return path.join(os.homedir(), ".config", "iteration", `${source}-collector`);
-}
-export function validateCollectorEndpoint(endpoint) {
-    let parsed;
-    try {
-        parsed = new URL(endpoint);
-    }
-    catch (error) {
-        throw new Error("Collector endpoint must be a valid URL.", {
-            cause: error,
-        });
-    }
-    const localHost = ["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname);
-    if (parsed.username !== "" ||
-        parsed.password !== "" ||
-        (parsed.protocol !== "https:" &&
-            !(parsed.protocol === "http:" && localHost))) {
-        throw new Error("Collector endpoint must use HTTPS, except for localhost.");
-    }
-    if (parsed.pathname !== "/api/traces/ingest" ||
-        parsed.search !== "" ||
-        parsed.hash !== "") {
-        throw new Error("Collector endpoint must be the trace ingest route without query parameters.");
-    }
-    return parsed;
-}
-export function collectorPaths(directory = defaultCollectorDirectory("codex")) {
-    return {
-        config: path.join(directory, "config.json"),
-        state: path.join(directory, "state.json"),
-        outbox: path.join(directory, "outbox.jsonl"),
-        redactionMarker: path.join(directory, "redaction.json"),
-        lock: path.join(directory, "collector.lock"),
-        historyBackfill: path.join(directory, "history-backfill.json"),
-        health: path.join(directory, "health.json"),
-    };
-}
-export async function assertFreshCollectorDirectory(paths, source = "codex") {
-    const state = await loadState(paths);
-    const configExists = await fs
-        .access(paths.config)
-        .then(() => true)
-        .catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return false;
-        throw error;
-    });
-    if (configExists) {
-        throw new Error(`This collector data directory is already configured. Run iteration status ${source} or iteration start ${source} to repair startup. Use a different --data-directory for another workspace, or iteration import-history ${source} for earlier sessions.`);
-    }
-    if (state.initialized || (await outboxSize(paths)) > 0) {
-        throw new Error("Collector state or pending events exist without a config. Use a different --data-directory; this data cannot be safely assigned to a new workspace.");
-    }
-}
-export async function ensurePrivateDirectory(directory) {
-    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
-    await fs.chmod(directory, 0o700);
-}
-async function writeJsonAtomic(filename, value) {
-    const temporary = `${filename}.${process.pid}.tmp`;
-    const handle = await fs.open(temporary, "w", 0o600);
-    try {
-        await handle.writeFile(`${JSON.stringify(value)}\n`, "utf8");
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await fs.rename(temporary, filename);
-}
-export async function saveConfig(config, paths) {
-    await ensurePrivateDirectory(path.dirname(paths.config));
-    await writeJsonAtomic(paths.config, config);
-}
-export async function loadHealth(paths) {
-    let contents;
-    try {
-        contents = await fs.readFile(paths.health, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return {
-                lastUploadAtMs: null,
-                historyCaughtUpAtMs: null,
-                lastFailure: null,
-            };
-        }
-        throw new Error(`Could not read collector health at ${paths.health}.`, {
-            cause: error,
-        });
-    }
-    let decoded;
-    try {
-        decoded = JSON.parse(contents);
-    }
-    catch (error) {
-        throw new Error("Collector health is not valid JSON.", { cause: error });
-    }
-    const parsed = healthSchema.safeParse(decoded);
-    if (!parsed.success) {
-        throw new Error("Collector health has an invalid shape.", {
-            cause: parsed.error,
-        });
-    }
-    return parsed.data;
-}
-export async function healthSnapshot(paths) {
-    try {
-        return { kind: "available", health: await loadHealth(paths) };
-    }
-    catch {
-        return {
-            kind: "unavailable",
-            health: {
-                lastUploadAtMs: null,
-                historyCaughtUpAtMs: null,
-                lastFailure: null,
-            },
-        };
-    }
-}
-export async function saveHealth(health, paths) {
-    await ensurePrivateDirectory(path.dirname(paths.health));
-    await writeJsonAtomic(paths.health, health);
-}
-export async function loadConfig(paths) {
-    let contents;
-    try {
-        contents = await fs.readFile(paths.config, "utf8");
-    }
-    catch (error) {
-        throw new Error(`Could not read collector config at ${paths.config}.`, {
-            cause: error,
-        });
-    }
-    let decoded;
-    try {
-        decoded = JSON.parse(contents);
-    }
-    catch (error) {
-        throw new Error("Collector config is not valid JSON.", { cause: error });
-    }
-    const parsed = configSchema.safeParse(decoded);
-    if (!parsed.success)
-        throw new Error("Collector config has an invalid shape.", {
-            cause: parsed.error,
-        });
-    validateCollectorEndpoint(parsed.data.endpoint);
-    const { token } = parsed.data;
-    if (token.length !== 43 || !/^[A-Za-z0-9_-]+$/.test(token)) {
-        throw new Error("Collector token has an invalid format.");
-    }
-    return parsed.data;
-}
-export async function loadState(paths) {
-    let contents;
-    try {
-        contents = await fs.readFile(paths.state, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-            return {
-                cursors: {},
-                skipping: [],
-                sourceDirectory: null,
-                initialized: false,
-            };
-        }
-        throw new Error(`Could not read collector checkpoint at ${paths.state}.`, {
-            cause: error,
-        });
-    }
-    let decoded;
-    try {
-        decoded = JSON.parse(contents);
-    }
-    catch (error) {
-        throw new Error("Collector checkpoint is not valid JSON.", {
-            cause: error,
-        });
-    }
-    const parsed = stateSchema.safeParse(decoded);
-    if (!parsed.success)
-        throw new Error("Collector checkpoint has an invalid shape.", {
-            cause: parsed.error,
-        });
-    return parsed.data;
-}
-export async function saveState(state, paths) {
-    await ensurePrivateDirectory(path.dirname(paths.state));
-    await writeJsonAtomic(paths.state, state);
-}
-export async function outboxSize(paths) {
-    try {
-        return (await fs.stat(paths.outbox)).size;
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return 0;
-        throw new Error("Could not inspect the local trace outbox.", {
-            cause: error,
-        });
-    }
-}
-export async function pendingEventIds(paths) {
-    const ids = new Set();
-    const size = await outboxSize(paths);
-    if (size > MAX_OUTBOX_BYTES)
-        throw new Error("Trace outbox exceeds its configured capacity.");
-    try {
-        const input = await fs.open(paths.outbox, "r");
-        const stream = input.createReadStream({
-            autoClose: true,
-            encoding: "utf8",
-        });
-        const lines = createInterface({ input: stream, crlfDelay: Infinity });
-        for await (const line of lines) {
-            ids.add(parseOutboxEvent(line).eventId);
-        }
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return ids;
-        throw error;
-    }
-    return ids;
-}
-export async function appendEvents(events, paths) {
-    if (events.length === 0)
-        return;
-    const contents = `${events.map((event) => JSON.stringify(event)).join("\n")}\n`;
-    const newSize = Buffer.byteLength(contents, "utf8");
-    const currentSize = await outboxSize(paths);
-    if (currentSize + newSize > MAX_OUTBOX_BYTES) {
-        throw new Error("Trace outbox is full; upload pending data before scanning more sessions.");
-    }
-    await ensurePrivateDirectory(path.dirname(paths.outbox));
-    const handle = await fs.open(paths.outbox, "a", 0o600);
-    try {
-        await handle.writeFile(contents, "utf8");
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-export async function redactPendingOutbox(paths) {
-    let marker;
-    try {
-        marker = await fs.readFile(paths.redactionMarker, "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            marker = null;
-        else
-            throw error;
-    }
-    if (marker !== null) {
-        let decoded;
-        try {
-            decoded = JSON.parse(marker);
-        }
-        catch {
-            throw new Error("Collector redaction marker is not valid JSON.");
-        }
-        if (!redactionMarkerSchema.safeParse(decoded).success)
-            throw new Error("Collector redaction marker has an invalid shape.");
-        return;
-    }
-    const size = await outboxSize(paths);
-    if (size > MAX_OUTBOX_BYTES)
-        throw new Error("Trace outbox exceeds its configured capacity.");
-    if (size > 0) {
-        const temporary = `${paths.outbox}.${process.pid}.redacting`;
-        const output = await fs.open(temporary, "w", 0o600);
-        try {
-            const lines = createInterface({
-                input: createReadStream(paths.outbox, { encoding: "utf8" }),
-                crlfDelay: Infinity,
-            });
-            for await (const line of lines) {
-                const event = await redactTraceEvent(parseOutboxEvent(line));
-                await output.writeFile(`${JSON.stringify(event)}\n`, "utf8");
-            }
-            await output.sync();
-        }
-        catch (error) {
-            await output.close();
-            await fs.rm(temporary, { force: true });
-            throw error;
-        }
-        await output.close();
-        try {
-            if ((await fs.stat(temporary)).size > MAX_OUTBOX_BYTES)
-                throw new Error("Redacted trace outbox exceeds its configured capacity.");
-            await fs.rename(temporary, paths.outbox);
-            const directory = await fs.open(path.dirname(paths.outbox), "r");
-            try {
-                await directory.sync();
-            }
-            finally {
-                await directory.close();
-            }
-        }
-        catch (error) {
-            await fs.rm(temporary, { force: true });
-            throw error;
-        }
-    }
-    await ensurePrivateDirectory(path.dirname(paths.redactionMarker));
-    await writeJsonAtomic(paths.redactionMarker, { version: 1 });
-}
-export async function nextBatch(paths, maxBytes) {
-    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
-        throw new Error("Maximum upload batch size must be a positive integer.");
-    }
-    const size = await outboxSize(paths);
-    if (size === 0)
-        return [];
-    if (size > MAX_OUTBOX_BYTES)
-        throw new Error("Trace outbox exceeds its configured capacity.");
-    const input = await fs.open(paths.outbox, "r");
-    const stream = input.createReadStream({ autoClose: true, encoding: "utf8" });
-    const lines = createInterface({ input: stream, crlfDelay: Infinity });
-    const events = [];
-    let bytes = 0;
-    for await (const line of lines) {
-        const lineBytes = Buffer.byteLength(line, "utf8") + 1;
-        if (events.length >= MAX_TRACE_EVENTS_PER_BATCH ||
-            (events.length > 0 && bytes + lineBytes > maxBytes)) {
-            lines.close();
-            stream.destroy();
-            break;
-        }
-        if (lineBytes > maxBytes) {
-            lines.close();
-            stream.destroy();
-            throw new Error("A queued event exceeds the maximum upload batch size.");
-        }
-        events.push(parseOutboxEvent(line));
-        bytes += lineBytes;
-    }
-    return events;
-}
-export async function acknowledgeEvents(acknowledgedIds, paths) {
-    const temporary = `${paths.outbox}.${process.pid}.tmp`;
-    const input = await fs.open(paths.outbox, "r").catch((error) => {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return null;
-        throw error;
-    });
-    if (input === null)
-        return;
-    const output = createWriteStream(temporary, { flags: "w", mode: 0o600 });
-    try {
-        const lines = createInterface({
-            input: input.createReadStream({ autoClose: true, encoding: "utf8" }),
-            crlfDelay: Infinity,
-        });
-        for await (const line of lines) {
-            const event = parseOutboxEvent(line);
-            if (!acknowledgedIds.has(event.eventId)) {
-                if (!output.write(`${line}\n`))
-                    await once(output, "drain");
-            }
-        }
-        output.end();
-        await once(output, "close");
-        const durable = await fs.open(temporary, "r+");
-        try {
-            await durable.sync();
-        }
-        finally {
-            await durable.close();
-        }
-        await fs.rename(temporary, paths.outbox);
-    }
-    catch (error) {
-        output.destroy();
-        await fs.rm(temporary, { force: true });
-        throw error;
-    }
-}
-export async function initializeState(source, home, paths, includeHistory) {
-    const state = await loadState(paths);
-    const sourceDirectory = path.resolve(home);
-    if (state.initialized && state.sourceDirectory !== sourceDirectory) {
-        throw new Error(`Collector state belongs to another ${source} directory; use a separate --data-directory.`);
-    }
-    if (state.initialized && state.sourceDirectory === sourceDirectory) {
-        if (includeHistory) {
-            throw new Error(`${source} is already connected. Run iteration import-history ${source} to import existing sessions.`);
-        }
-        return;
-    }
-    await saveState(await prepareSourceInitialState(source, home, includeHistory), paths);
-}
-export async function prepareSourceInitialState(source, home, includeHistory) {
-    const sourceDirectory = path.resolve(home);
-    const files = await sourceFiles(source, sourceDirectory);
-    const cursors = {};
-    if (!includeHistory) {
-        for (const filename of files) {
-            cursors[filename] = await lastCompleteRecordOffset(filename, (await fs.stat(filename)).size);
-        }
-    }
-    return {
-        cursors,
-        skipping: [],
-        sourceDirectory,
-        initialized: true,
-    };
-}
-export async function ensureStartableState(config, paths) {
-    const source = collectorSource(config);
-    const directory = collectorSourceDirectory(config);
-    const state = await loadState(paths);
-    if (state.initialized) {
-        if (state.sourceDirectory !== path.resolve(directory)) {
-            throw new Error(`Collector state belongs to another ${source} directory; use a separate --data-directory.`);
-        }
-        return false;
-    }
-    if ((await outboxSize(paths)) > 0) {
-        throw new Error("Pending events exist without an initialized checkpoint; repair the collector state before starting uploads.");
-    }
-    await saveState(await prepareSourceInitialState(source, directory, true), paths);
-    return true;
-}
-const HISTORY_BACKFILL_VERSION = 4;
-const historyBackfillMarkerSchema = z
-    .object({ version: z.number().int().min(1).max(HISTORY_BACKFILL_VERSION) })
-    .strict();
-async function readHistoryBackfillVersion(paths) {
-    let marker;
-    try {
-        marker = await fs.readFile(paths.historyBackfill, "utf8");
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            throw error;
-        return null;
-    }
-    let decoded;
-    try {
-        decoded = JSON.parse(marker);
-    }
-    catch (error) {
-        throw new Error("Collector history backfill marker is not valid JSON.", {
-            cause: error,
-        });
-    }
-    const parsed = historyBackfillMarkerSchema.safeParse(decoded);
-    if (!parsed.success) {
-        throw new Error("Collector history backfill marker has an invalid shape.", {
-            cause: parsed.error,
-        });
-    }
-    return parsed.data.version;
-}
-export async function ensureHistoryBackfill(codexHome, paths) {
-    const version = await readHistoryBackfillVersion(paths);
-    if (version !== null && version >= HISTORY_BACKFILL_VERSION)
-        return false;
-    const state = await loadState(paths);
-    if (!state.initialized || state.sourceDirectory !== path.resolve(codexHome)) {
-        throw new Error("Collector state does not match CODEX_HOME; reconnect Codex before uploading.");
-    }
-    await rolloutFiles(path.join(codexHome, "sessions"));
-    await saveState({ ...state, cursors: {}, skipping: [] }, paths);
-    await writeJsonAtomic(paths.historyBackfill, {
-        version: HISTORY_BACKFILL_VERSION,
-    });
-    return true;
-}
-// Version 2 re-reads Claude history so stored sessions gain each response's
-// final usage report and the PR links Claude records.
-const CLAUDE_HISTORY_BACKFILL_VERSION = 2;
-export async function ensureClaudeHistoryBackfill(claudeHome, paths) {
-    const version = await readHistoryBackfillVersion(paths);
-    if (version !== null && version >= CLAUDE_HISTORY_BACKFILL_VERSION)
-        return false;
-    const state = await loadState(paths);
-    if (!state.initialized ||
-        state.sourceDirectory !== path.resolve(claudeHome)) {
-        throw new Error("Collector state does not match the Claude directory; reconnect Claude before uploading.");
-    }
-    await claudeFiles(path.join(claudeHome, "projects"));
-    await saveState({ ...state, cursors: {}, skipping: [] }, paths);
-    await writeJsonAtomic(paths.historyBackfill, {
-        version: CLAUDE_HISTORY_BACKFILL_VERSION,
-    });
-    return true;
-}
-export async function ensureCursorHistoryBackfill(cursorHome, paths) {
-    const version = await readHistoryBackfillVersion(paths);
-    if (version !== null && version >= 1)
-        return false;
-    const state = await loadState(paths);
-    if (!state.initialized || state.sourceDirectory !== path.resolve(cursorHome))
-        throw new Error("Collector state does not match the Cursor directory; reconnect Cursor before uploading.");
-    await cursorFiles(path.join(cursorHome, "projects"));
-    await saveState({ ...state, cursors: {}, skipping: [] }, paths);
-    await writeJsonAtomic(paths.historyBackfill, { version: 1 });
-    return true;
-}
-export async function historyScanProgress(home, paths, source = "codex") {
-    if ((await readHistoryBackfillVersion(paths)) === null)
-        return { kind: "waiting" };
-    const state = await loadState(paths);
-    if (!state.initialized || state.sourceDirectory !== path.resolve(home)) {
-        throw new Error(`Collector state does not match the ${source} directory.`);
-    }
-    const files = await sourceFiles(source, home);
-    let scannedBytes = 0;
-    let totalBytes = 0;
-    for (let start = 0; start < files.length; start += 64) {
-        const batch = files.slice(start, start + 64);
-        const sizes = await Promise.all(batch.map(async (filename) => {
-            try {
-                return (await fs.stat(filename)).size;
-            }
-            catch (error) {
-                if (error instanceof Error &&
-                    "code" in error &&
-                    error.code === "ENOENT")
-                    return null;
-                throw error;
-            }
-        }));
-        for (const [index, size] of sizes.entries()) {
-            if (size === null)
-                continue;
-            const filename = batch[index];
-            if (filename === undefined)
-                continue;
-            totalBytes += size;
-            const cursor = state.cursors[filename] ?? 0;
-            scannedBytes += cursor <= size ? cursor : 0;
-            if (!Number.isSafeInteger(totalBytes) ||
-                !Number.isSafeInteger(scannedBytes)) {
-                throw new Error(`${source} history size exceeds the supported limit.`);
-            }
-        }
-    }
-    return { kind: "scanning", scannedBytes, totalBytes };
-}
-export async function resetHistoryCursors(home, paths, source = "codex") {
-    const state = await loadState(paths);
-    const sourceDirectory = path.resolve(home);
-    if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
-        throw new Error(`Connect the ${source} source before importing its history.`);
-    }
-    const files = await sourceFiles(source, sourceDirectory);
-    const cursors = {};
-    let bytes = 0;
-    for (const filename of files) {
-        cursors[filename] = 0;
-        bytes += (await fs.stat(filename)).size;
-        if (!Number.isSafeInteger(bytes)) {
-            throw new Error(`${source} history size exceeds the supported limit.`);
-        }
-    }
-    const localHealth = await healthSnapshot(paths);
-    if (localHealth.kind === "unavailable" ||
-        localHealth.health.historyCaughtUpAtMs !== null) {
-        await saveHealth({ ...localHealth.health, historyCaughtUpAtMs: null }, paths);
-    }
-    await saveState({
-        cursors,
-        skipping: [],
-        sourceDirectory,
-        initialized: true,
-    }, paths);
-    return { files: files.length, bytes };
-}
-export async function historyImportSize(home, source = "codex") {
-    const files = await sourceFiles(source, home);
-    let bytes = 0;
-    for (const filename of files) {
-        bytes += (await fs.stat(filename)).size;
-        if (!Number.isSafeInteger(bytes)) {
-            throw new Error(`${source} history size exceeds the supported limit.`);
-        }
-    }
-    return { files: files.length, bytes };
-}
-async function lastCompleteRecordOffset(filename, size) {
-    if (size === 0)
-        return 0;
-    const handle = await fs.open(filename, "r");
-    try {
-        const finalByte = Buffer.alloc(1);
-        await handle.read(finalByte, 0, 1, size - 1);
-        if (finalByte[0] === 10)
-            return size;
-        let end = size;
-        const minimum = Math.max(0, size - 32 * 1024 * 1024);
-        while (end > minimum) {
-            const start = Math.max(minimum, end - 64 * 1024);
-            const buffer = Buffer.alloc(end - start);
-            const result = await handle.read(buffer, 0, buffer.length, start);
-            const newline = buffer.subarray(0, result.bytesRead).lastIndexOf(10);
-            if (newline >= 0)
-                return start + newline + 1;
-            end = start;
-        }
-        if (size > 32 * 1024 * 1024) {
-            throw new Error(`Could not find a safe rollout boundary in ${filename}.`);
-        }
-        return 0;
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function rolloutFiles(root) {
-    const files = [];
-    const pending = [root];
-    while (pending.length > 0) {
-        const directory = pending.pop();
-        if (directory === undefined)
-            continue;
-        let entries;
-        try {
-            entries = await fs.readdir(directory, { withFileTypes: true });
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT")
-                continue;
-            throw new Error(`Could not scan Codex session directory ${directory}.`, {
-                cause: error,
-            });
-        }
-        for (const entry of entries) {
-            const filename = path.join(directory, entry.name);
-            if (entry.isDirectory())
-                pending.push(filename);
-            else if (entry.isFile() && /^rollout-.+\.jsonl$/.test(entry.name))
-                files.push(filename);
-            if (files.length > 10_000)
-                throw new Error("Codex session file count exceeds the scan limit.");
-        }
-    }
-    return files.sort();
-}
-async function directoryEntries(directory) {
-    try {
-        return await fs.readdir(directory, { withFileTypes: true });
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return [];
-        throw new Error(`Could not scan Claude session directory ${directory}.`, {
-            cause: error,
-        });
-    }
-}
-export async function claudeFiles(root) {
-    const files = [];
-    for (const project of await directoryEntries(root)) {
-        if (!project.isDirectory())
-            continue;
-        const projectDirectory = path.join(root, project.name);
-        for (const entry of await directoryEntries(projectDirectory)) {
-            const filename = path.join(projectDirectory, entry.name);
-            if (entry.isFile() &&
-                /^[^/]+\.jsonl$/.test(entry.name) &&
-                !entry.name.includes(".orphaned-") &&
-                !entry.name.includes(".superseded-")) {
-                files.push(filename);
-            }
-            else if (entry.isDirectory()) {
-                const subagents = path.join(filename, "subagents");
-                for (const agent of await directoryEntries(subagents)) {
-                    if (agent.isFile() && /^agent-.+\.jsonl$/.test(agent.name))
-                        files.push(path.join(subagents, agent.name));
-                }
-            }
-            if (files.length > 10_000)
-                throw new Error("Claude session file count exceeds the scan limit.");
-        }
-    }
-    return files.sort();
-}
-export function sourceFiles(source, home) {
-    const directory = path.resolve(home);
-    if (source === "codex")
-        return rolloutFiles(path.join(directory, "sessions"));
-    if (source === "claude")
-        return claudeFiles(path.join(directory, "projects"));
-    if (source === "cursor")
-        return cursorFiles(path.join(directory, "projects"));
-    const unhandled = source;
-    throw new Error(`Unsupported collector source: ${unhandled}`);
-}
-export async function cursorFiles(root) {
-    const files = [];
-    for (const project of await directoryEntries(root)) {
-        if (!project.isDirectory())
-            continue;
-        const transcripts = path.join(root, project.name, "agent-transcripts");
-        for (const conversation of await directoryEntries(transcripts)) {
-            if (!conversation.isDirectory())
-                continue;
-            const filename = path.join(transcripts, conversation.name, `${conversation.name}.jsonl`);
-            if ((await fs.stat(filename).catch((error) => {
-                if (error instanceof Error &&
-                    "code" in error &&
-                    error.code === "ENOENT")
-                    return null;
-                throw error;
-            }))?.isFile())
-                files.push(filename);
-            if (files.length > 10_000)
-                throw new Error("Cursor session file count exceeds the scan limit.");
-        }
-    }
-    return files.sort();
-}