iteration-cli 0.4.3 → 0.5.0

package/dist/cli.js

@@ -4,11 +4,13 @@ import path from "node:path";
 import { promises as fs } from "node:fs";
 import { parseArgs } from "node:util";
 import * as z from "zod";
+import { collectorSourceLabel, } from "iteration-trace-contracts";
 import { authenticateAndEnrollCollector } from "./clerk-device-auth.js";
-import { importCodexHistory } from "./history-import.js";
+import { importSourceHistory } from "./history-import.js";
 import { runCollector } from "./service.js";
+import { renderDetailedStatus, renderHome, } from "./status-view.js";
 import { installLaunchAgent, launchAgentStatus, uninstallLaunchAgent, } from "./launch-agent.js";
-import { assertFreshCollectorDirectory, collectorPaths, ensureStartableState, historyScanProgress, loadConfig, outboxSize, pendingEventIds, prepareInitialState, saveConfig, saveState, validateCollectorEndpoint, } from "./storage.js";
+import { assertFreshCollectorDirectory, collectorSource, collectorSourceDirectory, collectorPaths, defaultCollectorDirectory, ensureStartableState, healthSnapshot, historyScanProgress, loadConfig, outboxSize, pendingEventIds, prepareSourceInitialState, saveConfig, saveState, validateCollectorEndpoint, } from "./storage.js";
 const DEFAULT_INGEST_ENDPOINT = "https://useiteration.com/api/traces/ingest";
 function argumentsForCli() {
     const parsed = parseArgs({
@@ -21,6 +23,7 @@ function argumentsForCli() {
             "device-name": { type: "string" },
             "organization-id": { type: "string" },
             "codex-home": { type: "string" },
+            "claude-home": { type: "string" },
             "data-directory": { type: "string" },
             "include-history": { type: "boolean" },
             yes: { type: "boolean" },
@@ -48,8 +51,9 @@ function optionalString(values, name) {
 function usage(command) {
     if (command === "connect") {
         process.stdout.write([
-            "Connect Codex to Iteration",
+            "Connect a coding agent to Iteration",
             "  iteration connect codex",
+            "  iteration connect claude",
             "",
             "Existing local sessions and new activity are collected automatically.",
             "",
@@ -57,6 +61,7 @@ function usage(command) {
             "  --device-name NAME      Name this Mac in Iteration",
             "  --organization-id UUID  Select a workspace without a prompt",
             "  --codex-home DIR        Use a different Codex data directory",
+            "  --claude-home DIR       Use a different Claude data directory",
             "  --data-directory DIR   Use a different Iteration state directory",
             "  --endpoint URL         Use a different Iteration server",
         ].join("\n") + "\n");
@@ -66,47 +71,55 @@ function usage(command) {
         "Iteration CLI",
         "",
         "Get started:",
-        "  iteration                 Connect Codex, or show connection status",
+        "  iteration                 See connected sources or connect Codex",
         "",
         "Commands:",
         "  iteration connect codex   Connect Codex directly",
-        "  iteration status          Check uploads and connection",
-        "  iteration disconnect codex      Stop collecting",
+        "  iteration connect claude  Connect Claude Code directly",
+        "  iteration status          See scan, upload, and error details",
+        "  iteration disconnect codex|claude  Stop a source",
         "",
         "Run iteration connect codex --help for advanced setup options.",
     ].join("\n") + "\n");
 }
-async function configured(paths) {
+async function fileExists(filename) {
     try {
-        await fs.access(paths.config);
+        await fs.access(filename);
         return true;
     }
     catch (error) {
         if (error instanceof Error && "code" in error && error.code === "ENOENT") {
             return false;
         }
-        throw new Error(`Could not inspect collector config at ${paths.config}.`, {
+        throw new Error(`Could not inspect collector file at ${filename}.`, {
             cause: error,
         });
     }
 }
 async function defaultCommand() {
-    const paths = collectorPaths(dataDirectory({}));
-    if (await configured(paths)) {
-        await status({});
+    const [codex, claude] = await Promise.all([
+        statusSnapshot("codex", {}),
+        statusSnapshot("claude", {}),
+    ]);
+    const connected = [
+        { source: "codex", snapshot: codex },
+        { source: "claude", snapshot: claude },
+    ].filter(({ snapshot }) => snapshot.kind !== "not_connected");
+    if (connected.length > 0) {
+        process.stdout.write(`${connected.map(({ source, snapshot }) => renderHome(snapshot, Date.now(), source)).join("\n\n")}\n`);
         return;
     }
     if (process.stdin.isTTY !== true || process.stdout.isTTY !== true) {
-        process.stdout.write("Run iteration in a terminal to connect Codex.\n");
+        process.stdout.write("Run iteration connect codex or iteration connect claude in a terminal.\n");
         return;
     }
-    await initialize({});
+    await initialize("codex", {});
 }
-function dataDirectory(values) {
+function dataDirectory(source, values) {
     return path.resolve(optionalString(values, "data-directory") ??
-        path.join(os.homedir(), ".config", "iteration", "codex-collector"));
+        defaultCollectorDirectory(source));
 }
-async function initialize(values) {
+async function initialize(source, values) {
     if (process.platform !== "darwin") {
         throw new Error("Automatic startup is currently supported on macOS only.");
     }
@@ -114,118 +127,163 @@ async function initialize(values) {
     const endpointUrl = validateCollectorEndpoint(endpoint);
     const deviceName = optionalString(values, "device-name") ?? os.hostname();
     const organizationId = optionalString(values, "organization-id");
-    const directory = dataDirectory(values);
+    const directory = dataDirectory(source, values);
     const paths = collectorPaths(directory);
-    const codexHome = path.resolve(optionalString(values, "codex-home") ??
-        process.env.CODEX_HOME ??
-        path.join(os.homedir(), ".codex"));
-    await assertFreshCollectorDirectory(paths);
-    const preparedState = await prepareInitialState(codexHome, true);
-    const enrollment = await authenticateAndEnrollCollector(endpointUrl, deviceName, organizationId);
-    const config = {
+    const sourceHome = path.resolve(source === "codex"
+        ? (optionalString(values, "codex-home") ??
+            process.env.CODEX_HOME ??
+            path.join(os.homedir(), ".codex"))
+        : (optionalString(values, "claude-home") ??
+            process.env.CLAUDE_CONFIG_DIR ??
+            path.join(os.homedir(), ".claude")));
+    await assertFreshCollectorDirectory(paths, source);
+    const preparedState = await prepareSourceInitialState(source, sourceHome, true);
+    const enrollment = await authenticateAndEnrollCollector(endpointUrl, deviceName, organizationId, source);
+    const connection = {
         endpoint: endpointUrl.toString(),
         token: enrollment.token,
-        codexHome,
         dataDirectory: directory,
+        organizationName: enrollment.organizationName,
     };
+    const config = source === "codex"
+        ? { ...connection, codexHome: sourceHome }
+        : { ...connection, source: "claude", claudeHome: sourceHome };
     await saveConfig(config, paths);
     try {
         await saveState(preparedState, paths);
     }
     catch (error) {
-        throw new Error("Collector access was approved, but local setup did not finish. Run iteration start codex to repair it.", { cause: error });
+        throw new Error(`Collector access was approved, but local setup did not finish. Run iteration start ${source} to repair it.`, { cause: error });
     }
     try {
-        await installLaunchAgent(directory);
+        await installLaunchAgent(directory, source);
     }
     catch (error) {
-        throw new Error("Collector access was approved, but background startup failed. Run iteration start codex to retry it.", { cause: error });
+        throw new Error(`Collector access was approved, but background startup failed. Run iteration start ${source} to retry it.`, { cause: error });
     }
-    process.stdout.write(`Codex connected to ${enrollment.organizationName}. Existing local sessions and new activity will upload in the background. Run iteration status to check uploads.\n`);
+    process.stdout.write(`${collectorSourceLabel(source)} is connected to ${enrollment.organizationName}. Existing sessions are importing and new activity is collected automatically. Run iteration to check progress.\n`);
 }
-async function importHistory(values) {
+async function importHistory(source, values) {
     if (process.platform !== "darwin") {
         throw new Error("Automatic startup is currently supported on macOS only.");
     }
-    const directory = dataDirectory(values);
+    const directory = dataDirectory(source, values);
     const paths = collectorPaths(directory);
     const config = await loadConfig(paths);
-    const estimate = (await importCodexHistory(config, paths, false)).size;
-    process.stdout.write(`Found ${estimate.files} local Codex session files (${estimate.bytes} bytes). History may include prompts, code, and tool output that workspace members can read.\n`);
+    if (collectorSource(config) !== source)
+        throw new Error(`This collector directory belongs to ${collectorSource(config)}.`);
+    const estimate = (await importSourceHistory(config, paths, false)).size;
+    process.stdout.write(`Found ${estimate.files} local ${source} session files (${estimate.bytes} bytes). History may include prompts, code, and tool output that workspace members can read.\n`);
     if (values.yes !== true) {
-        process.stdout.write("No changes made. Run iteration import-history codex --yes to confirm this upload.\n");
+        process.stdout.write(`No changes made. Run iteration import-history ${source} --yes to confirm this upload.\n`);
         return;
     }
-    const result = await importCodexHistory(config, paths, true);
-    process.stdout.write(`History scan scheduled for ${result.size.files} local session files (${result.size.bytes} bytes). Scanning and uploads run in bounded batches and may take time. Older sessions appear under the date Iteration receives them. Use iteration status to see local scan progress and pending uploads.${result.backgroundRunning ? "" : " The collector was not running; run iteration start codex to begin scanning."}\n`);
+    const result = await importSourceHistory(config, paths, true);
+    process.stdout.write(`History scan scheduled for ${result.size.files} local session files (${result.size.bytes} bytes). Scanning and uploads run in bounded batches and may take time. Older sessions appear under the date Iteration receives them. Use iteration status ${source} to see local scan progress and pending uploads.${result.backgroundRunning ? "" : ` The collector was not running; run iteration start ${source} to begin scanning.`}\n`);
 }
-async function start(values) {
+async function start(source, values) {
     if (process.platform !== "darwin") {
         throw new Error("Automatic startup is currently supported on macOS only.");
     }
-    const directory = dataDirectory(values);
+    const directory = dataDirectory(source, values);
     const paths = collectorPaths(directory);
     const config = await loadConfig(paths);
+    if (collectorSource(config) !== source)
+        throw new Error(`This collector directory belongs to ${collectorSource(config)}.`);
     const repairedState = await ensureStartableState(config, paths);
-    await installLaunchAgent(directory);
-    process.stdout.write(`Collector started. Existing local sessions and new activity will upload in the background. Run iteration status to check uploads.${repairedState ? " Incomplete setup was repaired." : ""}\n`);
+    await installLaunchAgent(directory, source);
+    process.stdout.write(`${collectorSourceLabel(source)} is collecting again. Run iteration to check progress.${repairedState ? " Incomplete setup was repaired." : ""}\n`);
 }
-async function status(values) {
-    const paths = collectorPaths(dataDirectory(values));
-    if (!(await configured(paths))) {
-        process.stdout.write("Installed: false\nRunning: false\nPending events: 0\n");
-        return;
+async function statusSnapshot(source, values) {
+    const paths = collectorPaths(dataDirectory(source, values));
+    if (!(await fileExists(paths.config))) {
+        const [stateExists, pendingBytes] = await Promise.all([
+            fileExists(paths.state),
+            outboxSize(paths),
+        ]);
+        if (stateExists || pendingBytes > 0) {
+            return { kind: "needs_repair", pendingBytes, configPath: paths.config };
+        }
+        return { kind: "not_connected" };
     }
     const config = await loadConfig(paths);
-    const running = await launchAgentStatus();
-    const [size, ids, scan] = await Promise.all([
+    if (collectorSource(config) !== source)
+        throw new Error(`This collector directory belongs to ${collectorSource(config)}.`);
+    const [running, size, ids, scan, localHealth] = await Promise.all([
+        launchAgentStatus(source),
         outboxSize(paths),
         pendingEventIds(paths),
-        historyScanProgress(config.codexHome, paths),
+        historyScanProgress(collectorSourceDirectory(config), paths, source),
+        healthSnapshot(paths),
     ]);
-    const scanLabel = scan.kind === "waiting"
-        ? "Local history: waiting for collector start"
-        : scan.totalBytes === 0
-            ? "Local scan: no session data found"
-            : `Local scan: ${scan.scannedBytes} of ${scan.totalBytes} bytes processed`;
-    process.stdout.write([
-        "Installed: true",
-        `Running: ${running}`,
-        scanLabel,
-        `Pending events: ${ids.size}`,
-        `Pending bytes: ${size}`,
-    ].join("\n") + "\n");
+    const pendingEvents = size === 0 ? 0 : ids.size;
+    const pendingBytes = ids.size === 0 ? 0 : size;
+    return {
+        kind: "connected",
+        workspaceName: config.organizationName ?? null,
+        running,
+        scan,
+        pendingEvents,
+        pendingBytes,
+        health: localHealth.health,
+        healthAvailable: localHealth.kind === "available",
+        tracesUrl: new URL("/app/sessions", config.endpoint).toString(),
+        logPath: path.join(os.homedir(), "Library", "Logs", `iteration-${source}-collector.error.log`),
+    };
+}
+async function status(source, values) {
+    if (source !== undefined) {
+        const snapshot = await statusSnapshot(source, values);
+        process.stdout.write(`${renderDetailedStatus(snapshot, Date.now(), source)}\n`);
+        return;
+    }
+    const [codex, claude] = await Promise.all([
+        statusSnapshot("codex", values),
+        statusSnapshot("claude", values),
+    ]);
+    process.stdout.write(`${renderDetailedStatus(codex, Date.now(), "codex")}\n\n${renderDetailedStatus(claude, Date.now(), "claude")}\n`);
 }
 async function main() {
     const { command, source, values } = argumentsForCli();
+    const selectedSource = source === "codex" || source === "claude" ? source : null;
     if (values.help === true || command === "help") {
         return usage(command === "help" ? source : command);
     }
     if (values["include-history"] === true &&
-        !(command === "connect" && source === "codex")) {
+        !(command === "connect" && selectedSource !== null)) {
         throw new Error("Existing sessions are included automatically. Run iteration to connect.");
     }
     if (command === "" || (command === "connect" && source === undefined)) {
         if (Object.keys(values).length > 0) {
-            throw new Error("Options require a source. Run iteration connect codex --help for details.");
+            throw new Error("Options require a source. Run iteration connect --help for details.");
         }
         return defaultCommand();
     }
-    if (command === "connect" && source === "codex")
-        return initialize(values);
+    if (selectedSource !== null) {
+        if (selectedSource === "codex" && values["claude-home"] !== undefined)
+            throw new Error("--claude-home requires the Claude source.");
+        if (selectedSource === "claude" && values["codex-home"] !== undefined)
+            throw new Error("--codex-home requires the Codex source.");
+    }
+    if (command === "connect" && selectedSource !== null)
+        return initialize(selectedSource, values);
     if (command === "run") {
-        if (source !== undefined)
-            throw new Error("The run command takes no source.");
-        return runCollector(optionalString(values, "data-directory") ?? undefined);
-    }
-    if (command === "status" && (source === undefined || source === "codex"))
-        return status(values);
-    if (command === "import-history" && source === "codex")
-        return importHistory(values);
-    if (command === "start" && source === "codex")
-        return start(values);
-    if (command === "disconnect" && source === "codex") {
-        await uninstallLaunchAgent();
+        if (source !== undefined && selectedSource === null)
+            throw new Error("The run source must be codex or claude.");
+        return runCollector(optionalString(values, "data-directory") ?? undefined, selectedSource ?? undefined);
+    }
+    if (command === "status" &&
+        (source === undefined || selectedSource !== null)) {
+        if (source === undefined && values["data-directory"] !== undefined)
+            throw new Error("--data-directory requires a source with status.");
+        return status(selectedSource ?? undefined, values);
+    }
+    if (command === "import-history" && selectedSource !== null)
+        return importHistory(selectedSource, values);
+    if (command === "start" && selectedSource !== null)
+        return start(selectedSource, values);
+    if (command === "disconnect" && selectedSource !== null) {
+        await uninstallLaunchAgent(selectedSource);
         process.stdout.write("Collector startup removed. Local pending data was retained.\n");
         return;
     }

package/dist/collector.d.ts

@@ -1,7 +1,16 @@
 import { type CollectorConfig, type CollectorPaths } from "./storage.js";
-export declare function scanRolloutsOnce(config: CollectorConfig, paths: CollectorPaths, signal?: AbortSignal): Promise<number>;
-export declare function collectorTick(config: CollectorConfig, paths: CollectorPaths, fetcher?: typeof fetch, signal?: AbortSignal): Promise<Readonly<{
+export declare class TraceUploadError extends Error {
+    readonly kind: "http" | "network" | "response";
+    readonly status: number | null;
+    constructor(kind: "http" | "network" | "response", status: number | null, message: string, options?: ErrorOptions);
+}
+export declare function scanSourceOnce(config: CollectorConfig, paths: CollectorPaths, signal?: AbortSignal): Promise<Readonly<{
+    discovered: number;
+    caughtUp: boolean;
+}>>;
+export declare function collectorTick(config: CollectorConfig, paths: CollectorPaths, fetcher?: typeof fetch, signal?: AbortSignal, onAcknowledged?: () => void): Promise<Readonly<{
     discovered: number;
     uploaded: number;
     outboxBytes: number;
+    historyCaughtUp: boolean;
 }>>;

package/dist/collector.js

@@ -1,8 +1,9 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
 import { parseTraceEventAcknowledgement, } from "iteration-trace-contracts";
+import { parseClaudeLine } from "./claude-transcript.js";
 import { parseRolloutLine } from "./rollout.js";
-import { acknowledgeEvents, appendEvents, loadState, nextBatch, outboxSize, pendingEventIds, rolloutFiles, saveState, } from "./storage.js";
+import { acknowledgeEvents, appendEvents, collectorSource, collectorSourceDirectory, loadState, nextBatch, outboxSize, pendingEventIds, sourceFiles, saveState, } from "./storage.js";
 const MAX_SCAN_BYTES_PER_FILE = 16 * 1024 * 1024;
 const MAX_SCAN_BYTES_PER_TICK = 16 * 1024 * 1024;
 const MAX_RECORD_BYTES = 3 * 1024 * 1024;
@@ -11,6 +12,16 @@ const MAX_EVENT_BYTES = MAX_UPLOAD_BYTES - 1024;
 const MAX_UPLOADS_PER_TICK = 5;
 const MAX_REQUEST_BYTES = 4 * 1024 * 1024;
 const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
+export class TraceUploadError extends Error {
+    kind;
+    status;
+    constructor(kind, status, message, options) {
+        super(message, options);
+        this.name = "TraceUploadError";
+        this.kind = kind;
+        this.status = status;
+    }
+}
 function logGap(filename, offset, reason) {
     console.error(JSON.stringify({
         level: "capture_gap",
@@ -19,23 +30,41 @@ function logGap(filename, offset, reason) {
         reason,
     }));
 }
-export async function scanRolloutsOnce(config, paths, signal) {
+function parseSourceRecord(source, line, filename, byteOffset) {
+    if (source === "claude")
+        return parseClaudeLine(line, filename, byteOffset);
+    if (source === "codex") {
+        const parsed = parseRolloutLine(line, filename, byteOffset);
+        return parsed.kind === "event"
+            ? { events: [parsed.event], gaps: [] }
+            : parsed.kind === "gap"
+                ? { events: [], gaps: [parsed.reason] }
+                : { events: [], gaps: [] };
+    }
+    const unhandled = source;
+    throw new Error(`Unsupported collector source: ${unhandled}`);
+}
+export async function scanSourceOnce(config, paths, signal) {
     signal?.throwIfAborted();
+    const source = collectorSource(config);
+    const sourceDirectory = path.resolve(collectorSourceDirectory(config));
     const state = await loadState(paths);
-    if (!state.initialized ||
-        state.sourceDirectory !== path.resolve(config.codexHome)) {
-        throw new Error("Collector state does not match CODEX_HOME; run iteration connect codex again.");
+    if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
+        throw new Error(`Collector state does not match the ${source} directory; run iteration connect ${source} again.`);
     }
     const cursors = { ...state.cursors };
     const skipping = new Set(state.skipping);
-    const files = await rolloutFiles(path.join(config.codexHome, "sessions"));
+    const files = await sourceFiles(source, sourceDirectory);
     const queuedIds = await pendingEventIds(paths);
     const events = [];
     let remainingBudget = MAX_SCAN_BYTES_PER_TICK;
+    let caughtUp = true;
     for (const filename of files) {
         signal?.throwIfAborted();
-        if (remainingBudget === 0)
+        if (remainingBudget === 0) {
+            caughtUp = false;
             break;
+        }
         const stats = await fs.stat(filename);
         let offset = cursors[filename] ?? 0;
         if (offset > stats.size) {
@@ -50,15 +79,19 @@ export async function scanRolloutsOnce(config, paths, signal) {
         }
         const handle = await fs.open(filename, "r");
         let buffer;
+        let readEnd = offset;
         try {
             buffer = Buffer.alloc(bytesToRead);
             const result = await handle.read(buffer, 0, bytesToRead, offset);
             buffer = buffer.subarray(0, result.bytesRead);
+            readEnd = offset + result.bytesRead;
             remainingBudget -= result.bytesRead;
         }
         finally {
             await handle.close();
         }
+        if (readEnd < stats.size)
+            caughtUp = false;
         if (skipping.has(filename)) {
             const newline = buffer.indexOf(10);
             if (newline < 0) {
@@ -91,17 +124,19 @@ export async function scanRolloutsOnce(config, paths, signal) {
                 lineStart = index + 1;
                 continue;
             }
-            const parsed = parseRolloutLine(line, filename, byteOffset);
-            if (parsed.kind === "gap")
-                logGap(filename, byteOffset, parsed.reason);
-            if (parsed.kind === "event" && !queuedIds.has(parsed.event.eventId)) {
-                const eventBytes = Buffer.byteLength(JSON.stringify(parsed.event), "utf8");
+            const parsed = parseSourceRecord(source, line, filename, byteOffset);
+            for (const reason of parsed.gaps)
+                logGap(filename, byteOffset, reason);
+            for (const parsedEvent of parsed.events) {
+                if (queuedIds.has(parsedEvent.eventId))
+                    continue;
+                const eventBytes = Buffer.byteLength(JSON.stringify(parsedEvent), "utf8");
                 if (eventBytes > MAX_EVENT_BYTES) {
                     logGap(filename, byteOffset, "normalized_event_exceeds_upload_limit");
                 }
                 else {
-                    events.push(parsed.event);
-                    queuedIds.add(parsed.event.eventId);
+                    events.push(parsedEvent);
+                    queuedIds.add(parsedEvent.eventId);
                 }
             }
             lineStart = index + 1;
@@ -120,9 +155,9 @@ export async function scanRolloutsOnce(config, paths, signal) {
         sourceDirectory: state.sourceDirectory,
         initialized: true,
     }, paths);
-    return events.length;
+    return { discovered: events.length, caughtUp };
 }
-async function uploadPendingOnce(config, paths, fetcher = fetch, signal) {
+async function uploadPendingOnce(config, paths, fetcher = fetch, signal, onAcknowledged) {
     let uploaded = 0;
     for (let attempt = 0; attempt < MAX_UPLOADS_PER_TICK; attempt += 1) {
         signal?.throwIfAborted();
@@ -133,41 +168,54 @@ async function uploadPendingOnce(config, paths, fetcher = fetch, signal) {
         if (Buffer.byteLength(body, "utf8") > MAX_REQUEST_BYTES) {
             throw new Error("Queued trace batch exceeds the upload request limit.");
         }
-        const response = await fetcher(config.endpoint, {
-            method: "POST",
-            headers: {
-                authorization: `Bearer ${config.token}`,
-                "content-type": "application/json",
-            },
-            body,
-            signal: signal
-                ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
-                : AbortSignal.timeout(15_000),
-        });
+        let response;
+        try {
+            response = await fetcher(config.endpoint, {
+                method: "POST",
+                headers: {
+                    authorization: `Bearer ${config.token}`,
+                    "content-type": "application/json",
+                },
+                body,
+                signal: signal
+                    ? AbortSignal.any([signal, AbortSignal.timeout(15_000)])
+                    : AbortSignal.timeout(15_000),
+            });
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            throw new TraceUploadError("network", null, "Trace upload could not reach Iteration.", { cause: error });
+        }
         if (response.status !== 202) {
-            throw new Error(`Trace upload failed with HTTP ${response.status}.`);
+            throw new TraceUploadError("http", response.status, `Trace upload failed with HTTP ${response.status}.`);
         }
         let acknowledgement;
         try {
             acknowledgement = await response.json();
         }
         catch (error) {
-            throw new Error("Trace upload returned an unreadable acknowledgement.", {
-                cause: error,
-            });
+            throw new TraceUploadError("response", null, "Trace upload returned an unreadable acknowledgement.", { cause: error });
         }
         const expectedIds = batch.map((event) => event.eventId);
         const parsed = parseTraceEventAcknowledgement(acknowledgement, expectedIds);
-        if (!parsed.success)
-            throw new Error(parsed.error);
+        if (!parsed.success) {
+            throw new TraceUploadError("response", null, parsed.error);
+        }
         await acknowledgeEvents(new Set(parsed.value.acceptedEventIds), paths);
+        onAcknowledged?.();
         uploaded += batch.length;
     }
     return uploaded;
 }
-export async function collectorTick(config, paths, fetcher = fetch, signal) {
-    let uploaded = await uploadPendingOnce(config, paths, fetcher, signal);
-    const discovered = await scanRolloutsOnce(config, paths, signal);
-    uploaded += await uploadPendingOnce(config, paths, fetcher, signal);
-    return { discovered, uploaded, outboxBytes: await outboxSize(paths) };
+export async function collectorTick(config, paths, fetcher = fetch, signal, onAcknowledged) {
+    let uploaded = await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
+    const scan = await scanSourceOnce(config, paths, signal);
+    uploaded += await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
+    return {
+        discovered: scan.discovered,
+        uploaded,
+        outboxBytes: await outboxSize(paths),
+        historyCaughtUp: scan.caughtUp,
+    };
 }

package/dist/history-import.d.ts

@@ -9,7 +9,7 @@ export type HistoryImportControl = Readonly<{
     start: (directory: string) => Promise<unknown>;
     acquireLock: (paths: CollectorPaths) => Promise<() => Promise<void>>;
 }>;
-export declare function importCodexHistory(config: CollectorConfig, paths: CollectorPaths, confirmed: boolean, control?: HistoryImportControl): Promise<Readonly<{
+export declare function importSourceHistory(config: CollectorConfig, paths: CollectorPaths, confirmed: boolean, control?: HistoryImportControl): Promise<Readonly<{
     imported: boolean;
     size: HistoryImportSize;
     backgroundRunning: boolean | null;

package/dist/history-import.js

@@ -1,20 +1,23 @@
 import path from "node:path";
 import { installLaunchAgent, launchAgentStatus, uninstallLaunchAgent, } from "./launch-agent.js";
 import { waitForCollectorLock } from "./service.js";
-import { historyImportSize, loadState, resetHistoryCursors, } from "./storage.js";
-const macControl = {
-    isRunning: launchAgentStatus,
-    stop: uninstallLaunchAgent,
-    start: installLaunchAgent,
-    acquireLock: waitForCollectorLock,
-};
-export async function importCodexHistory(config, paths, confirmed, control = macControl) {
+import { collectorSource, collectorSourceDirectory, historyImportSize, loadState, resetHistoryCursors, } from "./storage.js";
+function macControl(source) {
+    return {
+        isRunning: () => launchAgentStatus(source),
+        stop: () => uninstallLaunchAgent(source),
+        start: (directory) => installLaunchAgent(directory, source),
+        acquireLock: waitForCollectorLock,
+    };
+}
+export async function importSourceHistory(config, paths, confirmed, control = macControl(collectorSource(config))) {
+    const source = collectorSource(config);
+    const directory = collectorSourceDirectory(config);
     const state = await loadState(paths);
-    if (!state.initialized ||
-        state.sourceDirectory !== path.resolve(config.codexHome)) {
-        throw new Error("Connect the Codex source before importing its history.");
+    if (!state.initialized || state.sourceDirectory !== path.resolve(directory)) {
+        throw new Error(`Connect the ${source} source before importing its history.`);
     }
-    const estimate = await historyImportSize(config.codexHome);
+    const estimate = await historyImportSize(directory, source);
     if (!confirmed)
         return { imported: false, size: estimate, backgroundRunning: null };
     const wasRunning = await control.isRunning();
@@ -29,7 +32,7 @@ export async function importCodexHistory(config, paths, confirmed, control = mac
         }
         const releaseLock = await control.acquireLock(paths);
         try {
-            size = await resetHistoryCursors(config.codexHome, paths);
+            size = await resetHistoryCursors(directory, paths, source);
             rewound = true;
         }
         finally {
@@ -45,8 +48,8 @@ export async function importCodexHistory(config, paths, confirmed, control = mac
         }
         catch (error) {
             throw new Error(rewound
-                ? "History checkpoints were rewound, but the collector could not restart. Run iteration start codex to resume uploads."
-                : "The collector could not be restored after a failed history import. Run iteration start codex to resume uploads.", {
+                ? `History checkpoints were rewound, but the collector could not restart. Run iteration start ${source} to resume uploads.`
+                : `The collector could not be restored after a failed history import. Run iteration start ${source} to resume uploads.`, {
                 cause: failure ? new AggregateError([failure.error, error]) : error,
             });
         }