iteration-cli 0.9.1 → 0.10.0

package/dist/launch-agent.js

@@ -1,183 +0,0 @@
-import { promisify } from "node:util";
-import { execFile as execFileCallback } from "node:child_process";
-import { promises as fs } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { setTimeout as sleep } from "node:timers/promises";
-import { fileURLToPath } from "node:url";
-const execFile = promisify(execFileCallback);
-function label(source) {
-    return `com.iteration.${source}-collector`;
-}
-const LAUNCHCTL_TIMEOUT_MS = 5_000;
-const RESTART_TIMEOUT_MS = 10_000;
-const RESTART_POLL_MS = 200;
-function xml(value) {
-    return value
-        .replaceAll("&", "&")
-        .replaceAll("<", "&lt;")
-        .replaceAll(">", "&gt;")
-        .replaceAll('"', "&quot;")
-        .replaceAll("'", "&apos;");
-}
-function plistPath(source, homeDirectory = os.homedir()) {
-    return path.join(homeDirectory, "Library", "LaunchAgents", `${label(source)}.plist`);
-}
-export function launchAgentPlist(cliPath = fileURLToPath(new URL("./cli.js", import.meta.url)), nodePath = process.execPath, logDirectory = path.join(os.homedir(), "Library", "Logs"), dataDirectory = path.join(os.homedir(), ".config", "iteration", "codex-collector"), source = "codex") {
-    const argumentsList = [
-        nodePath,
-        cliPath,
-        "run",
-        source,
-        "--data-directory",
-        dataDirectory,
-    ];
-    const argumentsXml = argumentsList
-        .map((argument) => `<string>${xml(argument)}</string>`)
-        .join("");
-    return [
-        '<?xml version="1.0" encoding="UTF-8"?>',
-        '<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">',
-        '<plist version="1.0"><dict>',
-        `<key>Label</key><string>${label(source)}</string>`,
-        `<key>ProgramArguments</key><array>${argumentsXml}</array>`,
-        "<key>RunAtLoad</key><true/>",
-        "<key>KeepAlive</key><true/>",
-        "<key>ThrottleInterval</key><integer>10</integer>",
-        `<key>StandardOutPath</key><string>${xml(path.join(logDirectory, `iteration-${source}-collector.log`))}</string>`,
-        `<key>StandardErrorPath</key><string>${xml(path.join(logDirectory, `iteration-${source}-collector.error.log`))}</string>`,
-        "</dict></plist>",
-    ].join("");
-}
-function launchctlTarget() {
-    const getUserId = process.getuid;
-    if (getUserId === undefined) {
-        throw new Error("Could not determine the current macOS user id.");
-    }
-    const userId = getUserId();
-    if (userId === undefined)
-        throw new Error("Could not determine the current macOS user id.");
-    return `gui/${userId}`;
-}
-function serviceMissing(error) {
-    const details = error;
-    return (String(details.code) === "113" ||
-        details.stderr?.includes("Could not find service") === true);
-}
-async function serviceLoaded(target, source, timeoutMs = LAUNCHCTL_TIMEOUT_MS) {
-    try {
-        await execFile("launchctl", ["print", `${target}/${label(source)}`], {
-            timeout: timeoutMs,
-        });
-        return true;
-    }
-    catch (error) {
-        if (serviceMissing(error))
-            return false;
-        throw error;
-    }
-}
-async function bootoutIfLoaded(target, source) {
-    if (!(await serviceLoaded(target, source)))
-        return false;
-    await execFile("launchctl", ["bootout", `${target}/${label(source)}`], {
-        timeout: LAUNCHCTL_TIMEOUT_MS,
-    });
-    return true;
-}
-function transientBootstrapFailure(error) {
-    const details = error;
-    return (String(details.code) === "5" ||
-        /^Bootstrap failed:\s*5\b/m.test(details.stderr ?? ""));
-}
-function restartTimeoutError(lastBootstrapFailure) {
-    return new Error(lastBootstrapFailure === undefined
-        ? "The previous Codex collector did not stop within 10 seconds."
-        : "launchctl bootstrap still failed with error 5 after 10 seconds.", { cause: lastBootstrapFailure });
-}
-export async function bootstrapAfterBootout(wasLoaded, control) {
-    if (!wasLoaded) {
-        await control.bootstrap(LAUNCHCTL_TIMEOUT_MS);
-        return;
-    }
-    const deadline = control.now() + RESTART_TIMEOUT_MS;
-    let lastBootstrapFailure;
-    while (true) {
-        let remaining = deadline - control.now();
-        if (remaining <= 0) {
-            throw restartTimeoutError(lastBootstrapFailure);
-        }
-        if (!(await control.isLoaded(Math.min(remaining, LAUNCHCTL_TIMEOUT_MS)))) {
-            remaining = deadline - control.now();
-            if (remaining <= 0)
-                continue;
-            try {
-                await control.bootstrap(Math.min(remaining, LAUNCHCTL_TIMEOUT_MS));
-                return;
-            }
-            catch (error) {
-                if (!transientBootstrapFailure(error))
-                    throw error;
-                lastBootstrapFailure = error;
-            }
-        }
-        remaining = deadline - control.now();
-        if (remaining > 0) {
-            await control.wait(Math.min(remaining, RESTART_POLL_MS));
-        }
-    }
-}
-export async function installLaunchAgent(dataDirectory, source = "codex") {
-    if (process.platform !== "darwin") {
-        throw new Error("Automatic startup is currently supported on macOS only.");
-    }
-    const file = plistPath(source);
-    const launchAgents = path.dirname(file);
-    const logs = path.join(os.homedir(), "Library", "Logs");
-    await fs.mkdir(launchAgents, { recursive: true, mode: 0o755 });
-    await fs.mkdir(logs, { recursive: true, mode: 0o755 });
-    await fs.writeFile(file, launchAgentPlist(undefined, undefined, undefined, dataDirectory ??
-        path.join(os.homedir(), ".config", "iteration", `${source}-collector`), source), { encoding: "utf8", mode: 0o644 });
-    const target = launchctlTarget();
-    const wasLoaded = await bootoutIfLoaded(target, source);
-    await bootstrapAfterBootout(wasLoaded, {
-        isLoaded: (timeoutMs) => serviceLoaded(target, source, timeoutMs),
-        bootstrap: async (timeoutMs) => {
-            await execFile("launchctl", ["bootstrap", target, file], {
-                timeout: timeoutMs,
-            });
-        },
-        wait: sleep,
-        now: Date.now,
-    });
-    await execFile("launchctl", ["kickstart", "-p", `${target}/${label(source)}`], {
-        timeout: LAUNCHCTL_TIMEOUT_MS,
-    });
-    return file;
-}
-export async function uninstallLaunchAgent(source = "codex") {
-    if (process.platform !== "darwin") {
-        throw new Error("Automatic startup is currently supported on macOS only.");
-    }
-    const file = plistPath(source);
-    await bootoutIfLoaded(launchctlTarget(), source);
-    await fs.rm(file, { force: true });
-}
-export async function launchAgentStatus(source = "codex") {
-    if (process.platform !== "darwin")
-        return false;
-    try {
-        const { stdout } = await execFile("launchctl", [
-            "print",
-            `${launchctlTarget()}/${label(source)}`,
-        ]);
-        return launchAgentRunning(stdout);
-    }
-    catch {
-        return false;
-    }
-}
-export function launchAgentRunning(output) {
-    const state = output.match(/^\s*state = ([^\r\n]+)$/m);
-    return state?.[1]?.trim() === "running";
-}

package/dist/redact-trace.d.ts

@@ -1,2 +0,0 @@
-import type { TraceEvent } from "iteration-trace-contracts";
-export declare function redactTraceEvent(event: TraceEvent): Promise<TraceEvent>;

package/dist/redact-trace.js

@@ -1,186 +0,0 @@
-import { lintSource } from "@secretlint/core";
-import { secretLintProfiler } from "@secretlint/profiler";
-import { rules as recommendedRules } from "@secretlint/secretlint-rule-preset-recommend";
-import * as z from "zod";
-// Secretlint profiles every rule run by default and keeps each timing entry,
-// so a long-running collector's memory would grow without limit.
-secretLintProfiler.setEnabled(false);
-const REDACTED = "[REDACTED]";
-const secretlintConfig = {
-    rules: recommendedRules
-        .filter((rule) => rule.meta.id !== "@secretlint/secretlint-rule-filter-comments")
-        .map((rule) => ({ id: rule.meta.id, rule })),
-};
-const assignment = /\b([A-Za-z][A-Za-z0-9_-]{0,79})["']?\s*[:=]\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s"'`,;}&]+))/g;
-const authorization = /\b(?:authorization|proxy-authorization)["']?\s*:\s*["']?(?:Bearer|Basic)\s+([A-Za-z0-9._~+/-]+={0,2})/gi;
-const privateKey = /-----BEGIN ((?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY)-----[\s\S]*?-----END \1-----/g;
-function normalizedKey(key) {
-    return key
-        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
-        .replace(/[^A-Za-z0-9]+/g, "_")
-        .toLowerCase();
-}
-function sensitiveKey(key) {
-    const normalized = normalizedKey(key);
-    if (/^(?:next_public|public|vite|react_app)_/.test(normalized))
-        return false;
-    return (/(?:^|_)(?:secret|password|passwd|credential)(?:_|$)/.test(normalized) ||
-        /(?:^|_)(?:api_key|private_key|database_url|db_url|dsn|connection_string|authorization|proxy_authorization|auth_header|cookie|set_cookie|token)$/.test(normalized));
-}
-function placeholder(value) {
-    const trimmed = value.trim();
-    return (trimmed === REDACTED ||
-        /^(?:<[^>]+>|\$\{[^}]+\}|\*+|redacted|placeholder|example|changeme|undefined|null)$/i.test(trimmed) ||
-        /^(?:process\.env|env)\.[A-Za-z0-9_]+$/.test(trimmed));
-}
-function addRange(ranges, start, end, length) {
-    if (!Number.isSafeInteger(start) ||
-        !Number.isSafeInteger(end) ||
-        start < 0 ||
-        end > length ||
-        start >= end) {
-        throw new Error("Local trace secret scanner returned an invalid location.");
-    }
-    ranges.push({ start, end });
-}
-function textRanges(value) {
-    const ranges = [];
-    for (const match of value.matchAll(assignment)) {
-        const key = match[1];
-        const candidate = match[2] ?? match[3] ?? match[4];
-        if (key === undefined ||
-            candidate === undefined ||
-            candidate.length === 0 ||
-            !sensitiveKey(key) ||
-            placeholder(candidate) ||
-            ((normalizedKey(key) === "authorization" ||
-                normalizedKey(key) === "proxy_authorization") &&
-                /^(?:Bearer|Basic)$/i.test(candidate)))
-            continue;
-        const start = match.index + match[0].lastIndexOf(candidate);
-        addRange(ranges, start, start + candidate.length, value.length);
-    }
-    for (const match of value.matchAll(authorization)) {
-        const candidate = match[1];
-        if (candidate === undefined || placeholder(candidate))
-            continue;
-        const start = match.index + match[0].lastIndexOf(candidate);
-        addRange(ranges, start, start + candidate.length, value.length);
-    }
-    for (const match of value.matchAll(privateKey)) {
-        addRange(ranges, match.index, match.index + match[0].length, value.length);
-    }
-    return ranges;
-}
-function replaceRanges(value, ranges) {
-    if (ranges.length === 0)
-        return value;
-    ranges.sort((a, b) => a.start - b.start || a.end - b.end);
-    const merged = [];
-    for (const range of ranges) {
-        const previous = merged.at(-1);
-        if (previous !== undefined && range.start <= previous.end) {
-            merged[merged.length - 1] = {
-                start: previous.start,
-                end: Math.max(previous.end, range.end),
-            };
-        }
-        else
-            merged.push(range);
-    }
-    let result = value;
-    for (let index = merged.length - 1; index >= 0; index -= 1) {
-        const range = merged[index];
-        if (range === undefined)
-            continue;
-        result = `${result.slice(0, range.start)}${REDACTED}${result.slice(range.end)}`;
-    }
-    return result;
-}
-async function redactText(value) {
-    if (value.length === 0 || value === REDACTED)
-        return value;
-    const ranges = textRanges(value);
-    let result;
-    try {
-        result = await lintSource({
-            source: {
-                contentType: "text",
-                content: value,
-                filePath: "trace.txt",
-                ext: "txt",
-            },
-            options: {
-                maskSecrets: true,
-                noPhysicFilePath: true,
-                config: secretlintConfig,
-            },
-        });
-    }
-    catch {
-        throw new Error("Local trace secret scanning failed; the event was not queued.");
-    }
-    for (const message of result.messages) {
-        addRange(ranges, message.range[0], message.range[1], value.length);
-    }
-    return replaceRanges(value, ranges);
-}
-async function redactValue(value, cache, force) {
-    const parsedText = z.string().safeParse(value);
-    if (parsedText.success) {
-        const text = parsedText.data;
-        if (force)
-            return placeholder(text) ? text : REDACTED;
-        let result = cache.get(text);
-        if (result === undefined) {
-            result = redactText(text);
-            cache.set(text, result);
-        }
-        return result;
-    }
-    if (value === null || value === true || value === false)
-        return value;
-    const parsedNumber = z.number().safeParse(value);
-    if (parsedNumber.success)
-        return force ? REDACTED : parsedNumber.data;
-    if (Array.isArray(value)) {
-        const items = await Promise.all(value.map((item) => redactValue(item, cache, force)));
-        return items.every((item, index) => item === value[index]) ? value : items;
-    }
-    const record = value;
-    const entries = await Promise.all(Object.entries(record).map(async ([key, item]) => [
-        key,
-        await redactValue(item, cache, force || sensitiveKey(key)),
-    ]));
-    return entries.every(([key, item]) => item === record[key])
-        ? value
-        : Object.fromEntries(entries);
-}
-export async function redactTraceEvent(event) {
-    const cache = new Map();
-    if (event.payload.sourceType === "cursor_subagent_transcript") {
-        const parsed = z.string().safeParse(event.payload.base64);
-        if (!parsed.success)
-            throw new Error("Cursor transcript has invalid encoded content.");
-        const bytes = Buffer.from(parsed.data, "base64");
-        if (bytes.toString("base64") !== parsed.data)
-            throw new Error("Cursor transcript has invalid encoded content.");
-        const raw = bytes.toString("latin1");
-        const redacted = await redactText(raw);
-        const { base64: _encoded, ...remaining } = event.payload;
-        const payload = await redactValue(remaining, cache, false);
-        return {
-            ...event,
-            payload: {
-                ...payload,
-                base64: redacted === raw
-                    ? parsed.data
-                    : Buffer.from(redacted, "latin1").toString("base64"),
-            },
-        };
-    }
-    const payload = await redactValue(event.payload, cache, false);
-    return payload === event.payload
-        ? event
-        : { ...event, payload: payload };
-}

package/dist/rollout.d.ts

@@ -1,11 +0,0 @@
-import { type TraceEvent } from "iteration-trace-contracts";
-export type RolloutParseResult = Readonly<{
-    kind: "event";
-    event: TraceEvent;
-}> | Readonly<{
-    kind: "ignored";
-}> | Readonly<{
-    kind: "gap";
-    reason: string;
-}>;
-export declare function parseRolloutLine(line: string, filename: string, byteOffset: number): RolloutParseResult;

package/dist/rollout.js

@@ -1,259 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { parseTracePayload, } from "iteration-trace-contracts";
-import * as z from "zod";
-const recordSchema = z.record(z.string(), z.unknown());
-const CONTEXT_RECORDS = [
-    "session_meta",
-    "turn_context",
-    "compacted",
-    "token_usage_record",
-    "world_state",
-    "retained_context",
-    "security_risk_score",
-];
-const RESPONSE_CONTEXT_TYPES = [
-    "reasoning",
-    "todo_list",
-    "compaction",
-    "context_compaction",
-    "configuration_update",
-    "additional_tools",
-];
-const EVENT_CONTEXT_TYPES = [
-    "task_complete",
-    "task_started",
-    "turn_complete",
-    "token_count",
-    "thread_goal_updated",
-    "thread_rolled_back",
-    "turn_aborted",
-    "thread_settings_applied",
-    "agent_reasoning",
-    "agent_reasoning_raw_content",
-];
-const COMPLETED_CONTEXT_TYPES = [
-    "reasoning",
-    "todo_list",
-];
-const IGNORED_EVENT_MESSAGES = ["turn_started"];
-function parseJsonRecord(value) {
-    const parsed = recordSchema.safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-function parseJsonString(value) {
-    const parsed = z.string().safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-function oneOf(value, allowed) {
-    return value !== null && allowed.includes(value);
-}
-const sourceOrdinalSchema = z
-    .number()
-    .int()
-    .min(0)
-    .max(Number.MAX_SAFE_INTEGER);
-function sourceOrdinal(value) {
-    const parsed = sourceOrdinalSchema.safeParse(value);
-    return parsed.success ? parsed.data : null;
-}
-function sessionFromPath(filename) {
-    const basename = path.basename(filename, ".jsonl");
-    return basename.startsWith("rollout-")
-        ? basename.slice("rollout-".length)
-        : basename;
-}
-function callIdFrom(record) {
-    return (parseJsonString(record.call_id) ?? parseJsonString(record.tool_call_id));
-}
-function sha256(value) {
-    return createHash("sha256").update(value, "utf8").digest("hex");
-}
-function safePayload(value) {
-    try {
-        const normalized = JSON.parse(JSON.stringify(value));
-        const parsed = parseTracePayload(normalized);
-        return parsed.success ? parsed.value : null;
-    }
-    catch {
-        return null;
-    }
-}
-function eventTimestamp(record) {
-    const timestamp = parseJsonString(record.timestamp);
-    return timestamp !== null && !Number.isNaN(Date.parse(timestamp))
-        ? timestamp
-        : null;
-}
-function capturedEvent(record, filename, byteOffset, eventType, payload, callId, run) {
-    const eventPayload = safePayload(payload);
-    if (eventPayload === null)
-        return { kind: "gap", reason: `invalid_${eventType}_payload` };
-    const sessionId = sessionFromPath(filename);
-    return {
-        kind: "event",
-        event: {
-            eventId: sha256(`${sessionId}:${byteOffset}`),
-            sessionId,
-            sequence: byteOffset,
-            callId,
-            projectId: null,
-            occurredAt: eventTimestamp(record),
-            eventType,
-            payload: eventPayload,
-            ...(run === undefined ? {} : { run }),
-        },
-    };
-}
-function mapResponseItem(payload) {
-    const type = parseJsonString(payload.type);
-    if (type === "message") {
-        const role = parseJsonString(payload.role);
-        if (role === "user")
-            return { eventType: "user_message", callId: null };
-        if (role === "assistant")
-            return { eventType: "assistant_message", callId: null };
-        return null;
-    }
-    if (type === "agent_message") {
-        return { eventType: "assistant_message", callId: null };
-    }
-    if (oneOf(type, RESPONSE_CONTEXT_TYPES)) {
-        return { eventType: type, callId: null };
-    }
-    if (oneOf(type, [
-        "function_call",
-        "custom_tool_call",
-        "mcp_tool_call",
-        "web_search_call",
-        "tool_search_call",
-        "image_generation_call",
-        "local_shell_call",
-    ])) {
-        return { eventType: "tool_call", callId: callIdFrom(payload) };
-    }
-    if (oneOf(type, [
-        "function_call_output",
-        "custom_tool_call_output",
-        "mcp_tool_call_output",
-        "web_search_output",
-        "tool_search_output",
-    ])) {
-        return { eventType: "tool_result", callId: callIdFrom(payload) };
-    }
-    return null;
-}
-function mapCompletedItem(item) {
-    const type = parseJsonString(item.type);
-    if (oneOf(type, [
-        "command_execution",
-        "mcp_tool_call",
-        "collab_tool_call",
-        "web_search",
-        "file_change",
-    ])) {
-        return { eventType: "tool_result", callId: callIdFrom(item) };
-    }
-    if (type === "agent_message") {
-        return { eventType: "assistant_message", callId: null };
-    }
-    if (oneOf(type, COMPLETED_CONTEXT_TYPES)) {
-        return { eventType: type, callId: null };
-    }
-    return null;
-}
-export function parseRolloutLine(line, filename, byteOffset) {
-    let decoded;
-    try {
-        decoded = JSON.parse(line);
-    }
-    catch {
-        return { kind: "gap", reason: "malformed_jsonl_record" };
-    }
-    const record = parseJsonRecord(decoded);
-    if (record === null)
-        return { kind: "gap", reason: "record_is_not_an_object" };
-    const recordType = parseJsonString(record.type);
-    const payload = parseJsonRecord(record.payload);
-    if (oneOf(recordType, CONTEXT_RECORDS)) {
-        if (payload === null)
-            return { kind: "gap", reason: `${recordType}_without_payload` };
-        let run;
-        if (recordType === "session_meta" &&
-            parseJsonString(payload.id) === sessionFromPath(filename).slice(-36)) {
-            const source = parseJsonRecord(payload.source);
-            const subagent = source === null ? null : parseJsonRecord(source.subagent);
-            const spawn = subagent === null ? null : parseJsonRecord(subagent.thread_spawn);
-            const parentId = parseJsonString(payload.parent_thread_id) ??
-                (spawn === null ? null : parseJsonString(spawn.parent_thread_id));
-            const startOrdinal = sourceOrdinal(payload.subagent_history_start_ordinal);
-            run = {
-                kind: "identity",
-                id: sessionFromPath(filename).slice(-36),
-                parentId,
-                ownStart: parentId === null,
-                startOrdinal,
-            };
-        }
-        return capturedEvent(record, filename, byteOffset, recordType, payload, null, run);
-    }
-    if (recordType === "response_item" && payload !== null) {
-        const mapped = mapResponseItem(payload);
-        if (mapped === null) {
-            const payloadType = parseJsonString(payload.type) ?? "unknown";
-            return {
-                kind: "gap",
-                reason: `unsupported_response_item:${payloadType}`,
-            };
-        }
-        return capturedEvent(record, filename, byteOffset, mapped.eventType, payload, mapped.callId);
-    }
-    if (recordType === "event_msg" && payload !== null) {
-        const messageType = parseJsonString(payload.type);
-        if (messageType === "user_message") {
-            return capturedEvent(record, filename, byteOffset, "user_message", payload, null);
-        }
-        if (messageType === "agent_message") {
-            return capturedEvent(record, filename, byteOffset, "assistant_message", payload, null);
-        }
-        if (oneOf(messageType, [
-            "mcp_tool_call_end",
-            "web_search_end",
-            "image_generation_end",
-            "patch_apply_end",
-        ])) {
-            return capturedEvent(record, filename, byteOffset, "tool_result", payload, callIdFrom(payload));
-        }
-        if (oneOf(messageType, IGNORED_EVENT_MESSAGES))
-            return { kind: "ignored" };
-        if (oneOf(messageType, EVENT_CONTEXT_TYPES)) {
-            const ordinal = sourceOrdinal(record.ordinal);
-            const run = messageType === "thread_settings_applied" &&
-                parseJsonString(payload.thread_id) ===
-                    sessionFromPath(filename).slice(-36) &&
-                ordinal !== null
-                ? { kind: "start", sourceOrdinal: ordinal }
-                : undefined;
-            return capturedEvent(record, filename, byteOffset, messageType, payload, null, run);
-        }
-        if (messageType !== "item_completed") {
-            return {
-                kind: "gap",
-                reason: `unsupported_event_message:${messageType ?? "unknown"}`,
-            };
-        }
-        const item = parseJsonRecord(payload.item);
-        if (item === null)
-            return { kind: "gap", reason: "item_completed_without_item" };
-        const mapped = mapCompletedItem(item);
-        if (mapped === null) {
-            const itemType = parseJsonString(item.type) ?? "unknown";
-            return { kind: "gap", reason: `unsupported_completed_item:${itemType}` };
-        }
-        return capturedEvent(record, filename, byteOffset, mapped.eventType, item, mapped.callId);
-    }
-    return {
-        kind: "gap",
-        reason: `unsupported_rollout_record:${recordType ?? "unknown"}`,
-    };
-}

package/dist/service.d.ts

@@ -1,5 +0,0 @@
-import type { CollectorSource } from "iteration-trace-contracts";
-import { type CollectorPaths } from "./storage.js";
-export declare function acquireCollectorLock(paths: CollectorPaths): Promise<() => Promise<void>>;
-export declare function waitForCollectorLock(paths: CollectorPaths): Promise<() => Promise<void>>;
-export declare function runCollector(directory?: string, expectedSource?: CollectorSource): Promise<void>;