iteration-cli 0.4.4 → 0.6.0

package/dist/cli.js

@@ -2,14 +2,18 @@
 import os from "node:os";
 import path from "node:path";
 import { promises as fs } from "node:fs";
+import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
 import * as z from "zod";
+import { COLLECTOR_SOURCES, collectorSourceLabel, } from "iteration-trace-contracts";
 import { authenticateAndEnrollCollector } from "./clerk-device-auth.js";
-import { importCodexHistory } from "./history-import.js";
+import { activateSource, connectedConfig, detectedSources, expandSource, loadMachineConsent, readCollectorScope, saveMachineConsent, sourceHome, } from "./auto-connect.js";
+import { importSourceHistory } from "./history-import.js";
 import { runCollector } from "./service.js";
-import { renderDetailedStatus, renderHome, } from "./status-view.js";
+import { renderDetailedStatus, renderHome, safeWorkspaceName, } from "./status-view.js";
+import { installTurnSummary, turnSummaryApprovalHint, uninstallTurnSummary, } from "./turn-summary.js";
 import { installLaunchAgent, launchAgentStatus, uninstallLaunchAgent, } from "./launch-agent.js";
-import { assertFreshCollectorDirectory, collectorPaths, ensureStartableState, healthSnapshot, 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({
@@ -22,6 +26,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" },
@@ -49,8 +54,10 @@ 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         Connect all detected agents on this Mac",
             "  iteration connect codex",
+            "  iteration connect claude",
             "",
             "Existing local sessions and new activity are collected automatically.",
             "",
@@ -58,7 +65,9 @@ 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",
-            "  --data-directory DIR   Use a different Iteration state directory",
+            "  --claude-home DIR       Use a different Claude data directory",
+            "  --yes                  Approve uploads without a terminal prompt",
+            "  --data-directory DIR   Use a different state directory with a source-specific command",
             "  --endpoint URL         Use a different Iteration server",
         ].join("\n") + "\n");
         return;
@@ -67,14 +76,15 @@ function usage(command) {
         "Iteration CLI",
         "",
         "Get started:",
-        "  iteration                 Connect Codex, or see its current activity",
+        "  iteration connect         Connect detected agents and import sessions",
         "",
         "Commands:",
-        "  iteration connect codex   Connect Codex directly",
+        "  iteration                 See connection status",
         "  iteration status          See scan, upload, and error details",
-        "  iteration disconnect codex      Stop collecting",
+        "  iteration connect codex|claude  Connect one source (advanced)",
+        "  iteration disconnect codex|claude  Stop a source",
         "",
-        "Run iteration connect codex --help for advanced setup options.",
+        "Run iteration connect --help for advanced setup options.",
     ].join("\n") + "\n");
 }
 async function fileExists(filename) {
@@ -92,22 +102,46 @@ async function fileExists(filename) {
     }
 }
 async function defaultCommand() {
-    const snapshot = await statusSnapshot({});
-    if (snapshot.kind !== "not_connected") {
-        process.stdout.write(`${renderHome(snapshot)}\n`);
+    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`);
+        const discovered = await detectedSources({
+            codex: sourceHome("codex"),
+            claude: sourceHome("claude"),
+        });
+        const missing = discovered.filter((source) => (source === "codex" ? codex : claude).kind === "not_connected");
+        if (missing.length > 0) {
+            process.stdout.write(`\n${missing.map(collectorSourceLabel).join(" and ")} found on this Mac but not connected. Run iteration connect to include ${missing.length === 1 ? "it" : "them"}.\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 in a terminal.\n");
         return;
     }
-    await initialize({});
+    await connectAll({});
 }
-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 turnSummaryNotice(config) {
+    try {
+        await installTurnSummary(config);
+        return ` A one-line friction summary now appears after agent turns in your repositories.${turnSummaryApprovalHint(config)}`;
+    }
+    catch (error) {
+        return ` The turn summary could not be installed: ${error instanceof Error ? error.message : "unknown error"} Run iteration start ${collectorSource(config)} to retry it.`;
+    }
+}
+async function initialize(source, values) {
     if (process.platform !== "darwin") {
         throw new Error("Automatic startup is currently supported on macOS only.");
     }
@@ -115,65 +149,204 @@ 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,
+        organizationId: enrollment.organizationId,
         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 });
+    }
+    const notice = await turnSummaryNotice(config);
+    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.${notice}\n`);
+    return config;
+}
+async function approveAllSources(sources, workspaceName, yes) {
+    const names = sources.map(collectorSourceLabel).join(" and ");
+    const safeName = safeWorkspaceName(workspaceName);
+    process.stdout.write(`Detected ${names || "no saved agent sessions"} on this Mac.\n` +
+        `Connect supported agents${safeName ? ` to ${safeName}` : " to the workspace you select"}? Existing sessions and future activity, including prompts, code, and tool output, will be uploaded. Workspace members can read them. Newly detected supported agents will connect automatically.\n`);
+    if (yes)
+        return;
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Run iteration connect interactively or pass --yes to approve uploads.");
+    }
+    const prompt = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = (await prompt.question("Connect agents? [y/N] "))
+            .trim()
+            .toLowerCase();
+        if (answer !== "y" && answer !== "yes")
+            throw new Error("No agents were connected.");
+    }
+    finally {
+        prompt.close();
     }
-    process.stdout.write(`Codex 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 connectAll(values) {
     if (process.platform !== "darwin") {
         throw new Error("Automatic startup is currently supported on macOS only.");
     }
-    const directory = dataDirectory(values);
+    if (values["data-directory"] !== undefined) {
+        throw new Error("--data-directory requires a source-specific connect command.");
+    }
+    const configs = await Promise.all(COLLECTOR_SOURCES.map(connectedConfig));
+    const sourceHomes = {
+        codex: path.resolve(optionalString(values, "codex-home") ??
+            (configs[0] && "codexHome" in configs[0]
+                ? configs[0].codexHome
+                : sourceHome("codex"))),
+        claude: path.resolve(optionalString(values, "claude-home") ??
+            (configs[1] && "claudeHome" in configs[1]
+                ? configs[1].claudeHome
+                : sourceHome("claude"))),
+    };
+    const detected = await detectedSources(sourceHomes);
+    const existing = COLLECTOR_SOURCES.flatMap((source, index) => configs[index] ? [{ source, config: configs[index] }] : []);
+    if (detected.length === 0 && existing.length === 0) {
+        process.stdout.write("No supported local coding agents found yet. Run iteration connect after using Codex or Claude Code on this Mac.\n");
+        return;
+    }
+    const anchorSource = existing[0]?.source ?? detected[0];
+    const anchorExisting = existing[0]?.config ?? null;
+    const endpoint = validateCollectorEndpoint(optionalString(values, "endpoint") ??
+        anchorExisting?.endpoint ??
+        DEFAULT_INGEST_ENDPOINT).toString();
+    const existingScopes = await Promise.all(existing.map(async (item) => ({
+        ...item,
+        scope: await readCollectorScope(item.config),
+    })));
+    for (const item of existingScopes) {
+        if (item.config.endpoint !== endpoint) {
+            throw new Error("Existing sources use different Iteration servers. Connect one source at a time.");
+        }
+        if (existingScopes[0]?.scope.organizationId !== item.scope.organizationId) {
+            throw new Error("Existing sources use different workspaces. Connect one source at a time.");
+        }
+    }
+    const requestedOrganizationId = optionalString(values, "organization-id");
+    if (requestedOrganizationId &&
+        existingScopes[0] &&
+        requestedOrganizationId !== existingScopes[0].scope.organizationId) {
+        throw new Error("The existing collector belongs to a different workspace.");
+    }
+    const previousConsent = await loadMachineConsent();
+    if (previousConsent === null ||
+        anchorExisting === null ||
+        previousConsent.endpoint !== endpoint ||
+        previousConsent.anchorSource !== anchorSource ||
+        previousConsent.anchorDataDirectory !== anchorExisting.dataDirectory ||
+        previousConsent.organizationId !==
+            existingScopes[0]?.scope.organizationId ||
+        previousConsent.sourceHomes.codex !== sourceHomes.codex ||
+        previousConsent.sourceHomes.claude !== sourceHomes.claude) {
+        await approveAllSources(detected, existingScopes[0]?.scope.organizationName ?? null, values.yes === true);
+    }
+    let anchor = anchorExisting ?? (await initialize(anchorSource, values));
+    let organizationId = requestedOrganizationId ??
+        existingScopes[0]?.scope.organizationId ??
+        anchor.organizationId ??
+        null;
+    for (const source of detected) {
+        if (source === anchorSource ||
+            configs[COLLECTOR_SOURCES.indexOf(source)] !== null)
+            continue;
+        const paths = collectorPaths(defaultCollectorDirectory(source));
+        await assertFreshCollectorDirectory(paths, source);
+        const state = await prepareSourceInitialState(source, sourceHomes[source], true);
+        const enrollment = await expandSource(anchor, source, organizationId);
+        const config = await activateSource(source, sourceHomes[source], endpoint, enrollment, state);
+        organizationId = enrollment.organizationId;
+        const notice = await turnSummaryNotice(config);
+        process.stdout.write(`${collectorSourceLabel(source)} is connected to ${enrollment.organizationName}.${notice}\n`);
+    }
+    if (organizationId === null) {
+        organizationId = (await readCollectorScope(anchor)).organizationId;
+    }
+    if (anchor.organizationId === undefined) {
+        anchor = { ...anchor, organizationId };
+        await saveConfig(anchor, collectorPaths(anchor.dataDirectory));
+    }
+    await saveMachineConsent({
+        version: 1,
+        endpoint,
+        organizationId,
+        anchorSource,
+        anchorDataDirectory: anchor.dataDirectory,
+        sourceHomes,
+    });
+    for (const item of existing) {
+        await ensureStartableState(item.config, collectorPaths(item.config.dataDirectory));
+        await installLaunchAgent(item.config.dataDirectory, item.source);
+        const notice = await turnSummaryNotice(item.config);
+        process.stdout.write(`${collectorSourceLabel(item.source)} is still connected.${notice}\n`);
+    }
+    process.stdout.write("Detected agents are connected. New supported agents on this Mac will connect automatically.\n");
+}
+async function importHistory(source, values) {
+    if (process.platform !== "darwin") {
+        throw new Error("Automatic startup is currently supported on macOS only.");
+    }
+    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(`Codex is collecting again. Run iteration to check progress.${repairedState ? " Incomplete setup was repaired." : ""}\n`);
+    await installLaunchAgent(directory, source);
+    const notice = await turnSummaryNotice(config);
+    process.stdout.write(`${collectorSourceLabel(source)} is collecting again. Run iteration to check progress.${repairedState ? " Incomplete setup was repaired." : ""}${notice}\n`);
 }
-async function statusSnapshot(values) {
-    const paths = collectorPaths(dataDirectory(values));
+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),
@@ -185,11 +358,13 @@ async function statusSnapshot(values) {
         return { kind: "not_connected" };
     }
     const config = await loadConfig(paths);
+    if (collectorSource(config) !== source)
+        throw new Error(`This collector directory belongs to ${collectorSource(config)}.`);
     const [running, size, ids, scan, localHealth] = await Promise.all([
-        launchAgentStatus(),
+        launchAgentStatus(source),
         outboxSize(paths),
         pendingEventIds(paths),
-        historyScanProgress(config.codexHome, paths),
+        historyScanProgress(collectorSourceDirectory(config), paths, source),
         healthSnapshot(paths),
     ]);
     const pendingEvents = size === 0 ? 0 : ids.size;
@@ -204,43 +379,71 @@ async function statusSnapshot(values) {
         health: localHealth.health,
         healthAvailable: localHealth.kind === "available",
         tracesUrl: new URL("/app/sessions", config.endpoint).toString(),
-        logPath: path.join(os.homedir(), "Library", "Logs", "iteration-codex-collector.error.log"),
+        logPath: path.join(os.homedir(), "Library", "Logs", `iteration-${source}-collector.error.log`),
     };
 }
-async function status(values) {
-    const snapshot = await statusSnapshot(values);
-    process.stdout.write(`${renderDetailedStatus(snapshot)}\n`);
+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 (command === "connect" && source === undefined) {
+        return connectAll(values);
+    }
+    if (command === "") {
         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) {
+        await initialize(selectedSource, values);
+        return;
+    }
     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);
+        const paths = collectorPaths(dataDirectory(selectedSource, values));
+        if (await fileExists(paths.config)) {
+            await uninstallTurnSummary(await loadConfig(paths));
+        }
         process.stdout.write("Collector startup removed. Local pending data was retained.\n");
         return;
     }

package/dist/collector.d.ts

@@ -4,7 +4,7 @@ export declare class TraceUploadError extends Error {
     readonly status: number | null;
     constructor(kind: "http" | "network" | "response", status: number | null, message: string, options?: ErrorOptions);
 }
-export declare function scanRolloutsOnce(config: CollectorConfig, paths: CollectorPaths, signal?: AbortSignal): Promise<Readonly<{
+export declare function scanSourceOnce(config: CollectorConfig, paths: CollectorPaths, signal?: AbortSignal): Promise<Readonly<{
     discovered: number;
     caughtUp: 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;
@@ -29,16 +30,31 @@ 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;
@@ -108,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;
@@ -192,7 +210,7 @@ async function uploadPendingOnce(config, paths, fetcher = fetch, signal, onAckno
 }
 export async function collectorTick(config, paths, fetcher = fetch, signal, onAcknowledged) {
     let uploaded = await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
-    const scan = await scanRolloutsOnce(config, paths, signal);
+    const scan = await scanSourceOnce(config, paths, signal);
     uploaded += await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
     return {
         discovered: scan.discovered,

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,
             });
         }

package/dist/launch-agent.d.ts

@@ -1,12 +1,13 @@
+import type { CollectorSource } from "iteration-trace-contracts";
 export type LaunchAgentRestart = {
     isLoaded(timeoutMs: number): Promise<boolean>;
     bootstrap(timeoutMs: number): Promise<void>;
     wait(delayMs: number): Promise<void>;
     now(): number;
 };
-export declare function launchAgentPlist(cliPath?: string, nodePath?: string, logDirectory?: string, dataDirectory?: string): string;
+export declare function launchAgentPlist(cliPath?: string, nodePath?: string, logDirectory?: string, dataDirectory?: string, source?: CollectorSource): string;
 export declare function bootstrapAfterBootout(wasLoaded: boolean, control: LaunchAgentRestart): Promise<void>;
-export declare function installLaunchAgent(dataDirectory?: string): Promise<string>;
-export declare function uninstallLaunchAgent(): Promise<void>;
-export declare function launchAgentStatus(): Promise<boolean>;
+export declare function installLaunchAgent(dataDirectory?: string, source?: CollectorSource): Promise<string>;
+export declare function uninstallLaunchAgent(source?: CollectorSource): Promise<void>;
+export declare function launchAgentStatus(source?: CollectorSource): Promise<boolean>;
 export declare function launchAgentRunning(output: string): boolean;