iteration-cli 0.4.4 → 0.5.0

package/README.md

@@ -4,10 +4,15 @@ Install one CLI for Iteration's supported coding-agent sources:
 
 ```sh
 npm install --global iteration-cli
-iteration
+iteration connect codex
+iteration connect claude
 ```
 
-The Codex collector currently runs on macOS with Node.js 22 or later. Connecting imports existing local Codex sessions and collects new activity. Run `iteration` to see whether collection and uploads are healthy, `iteration status` for details, or `iteration help` for other commands.
+The collectors currently run on macOS with Node.js 22 or later. Connect either source or both on the same Mac. Each source has its own background process, local checkpoint, and upload queue. Connecting imports existing local sessions and collects new activity. Run `iteration` to see connected sources, `iteration status codex` or `iteration status claude` for details, and `iteration help` for other commands.
+
+Claude Code sessions are read from `~/.claude/projects`, including session subagents. If Claude uses `CLAUDE_CONFIG_DIR`, the collector follows that setting during connection; `iteration connect claude --claude-home DIR` selects another directory explicitly. The collector reads only saved local JSONL records. Claude Code may remove old transcripts under its own retention settings, so connect before local history is removed. The records can contain prompts, reasoning, tool input and output, and context snapshots; workspace members can read what uploads. Unknown record shapes are reported as capture gaps in the collector log. Remote Claude sessions are outside this local collector.
+
+To rescan older local sessions, preview with `iteration import-history claude`, then confirm with `iteration import-history claude --yes`. Use `iteration start claude` to restart collection and `iteration disconnect claude` to stop its background process without deleting local pending data.
 
 If you previously installed the Codex-specific package, remove it with the package manager you used:
 

package/dist/claude-transcript.d.ts

@@ -0,0 +1,6 @@
+import { type TraceEvent } from "iteration-trace-contracts";
+export type ClaudeParseResult = Readonly<{
+    events: readonly TraceEvent[];
+    gaps: readonly string[];
+}>;
+export declare function parseClaudeLine(line: string, filename: string, byteOffset: number): ClaudeParseResult;

package/dist/claude-transcript.js

@@ -0,0 +1,255 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import * as z from "zod";
+import { parseTraceEventBatch, } from "iteration-trace-contracts";
+const CONTEXT_RECORD_TYPES = new Set([
+    "attachment",
+    "system",
+    "last-prompt",
+    "mode",
+    "permission-mode",
+    "atis-latch",
+    "ai-title",
+    "file-history-snapshot",
+    "file-history-delta",
+    "cost-state",
+    "queue-operation",
+]);
+function object(value) {
+    const parsed = z.record(z.string(), z.json()).safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function string(value) {
+    const parsed = z.string().safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function digest(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+const URL_NAMESPACE = Buffer.from("6ba7b8119dad11d180b400c04fd430c8", "hex");
+function childThreadId(parentId, agentId) {
+    const bytes = createHash("sha1")
+        .update(URL_NAMESPACE)
+        .update(`https://github.com/Thytu/Iteration/claude/${parentId}/agent/${agentId}`)
+        .digest()
+        .subarray(0, 16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x50;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    const hex = bytes.toString("hex");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+const SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function claudeSessionIdentity(filename) {
+    if (!filename.endsWith(".jsonl"))
+        return null;
+    const basename = path.basename(filename, ".jsonl");
+    if (path.basename(path.dirname(filename)) === "subagents") {
+        const parent = path.basename(path.dirname(path.dirname(filename)));
+        if (!basename.startsWith("agent-") || !SESSION_UUID.test(parent))
+            return null;
+        const agentId = basename.slice("agent-".length);
+        if (agentId.length === 0)
+            return null;
+        const threadId = childThreadId(parent, agentId);
+        const sessionId = `claude:${threadId}`;
+        const runId = `${parent}/agent/${agentId}`;
+        if (sessionId.length > 200 || runId.length > 200)
+            return null;
+        return {
+            sessionId,
+            parentSessionId: `claude:${parent}`,
+            agentId,
+            runId,
+            parentRunId: parent,
+        };
+    }
+    const sessionId = `claude:${basename}`;
+    return sessionId.length <= 200 && SESSION_UUID.test(basename)
+        ? {
+            sessionId,
+            parentSessionId: null,
+            agentId: null,
+            runId: basename,
+            parentRunId: null,
+        }
+        : null;
+}
+function timestamp(record) {
+    const value = string(record.timestamp);
+    return value !== null &&
+        /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) &&
+        !Number.isNaN(Date.parse(value))
+        ? value
+        : null;
+}
+function event(identity, record, byteOffset, index, eventType, payload, callId = null, stableKey) {
+    return {
+        eventId: `${String(index).padStart(4, "0")}:${digest(`${identity.sessionId}:${stableKey ?? string(record.uuid) ?? `${byteOffset}:${JSON.stringify(record)}`}`)}`,
+        sessionId: identity.sessionId,
+        sequence: byteOffset,
+        callId,
+        projectId: null,
+        occurredAt: timestamp(record),
+        eventType,
+        payload,
+    };
+}
+function contentText(value) {
+    const literal = string(value);
+    if (literal !== null)
+        return literal;
+    if (!Array.isArray(value))
+        return null;
+    const parts = value.flatMap((part) => {
+        const block = object(part);
+        const text = block === null ? null : string(block.text);
+        return text === null ? [] : [text];
+    });
+    return parts.length > 0 ? parts.join("\n") : null;
+}
+export function parseClaudeLine(line, filename, byteOffset) {
+    const identity = claudeSessionIdentity(filename);
+    if (identity === null)
+        return { events: [], gaps: ["invalid_claude_session_path"] };
+    let decoded;
+    try {
+        decoded = JSON.parse(line);
+    }
+    catch {
+        return { events: [], gaps: ["malformed_jsonl_record"] };
+    }
+    const record = object(decoded);
+    if (record === null)
+        return { events: [], gaps: ["record_is_not_an_object"] };
+    const recordType = string(record.type);
+    const sourceSessionId = string(record.sessionId);
+    if ((identity.agentId !== null && sourceSessionId === null) ||
+        (sourceSessionId !== null &&
+            `claude:${sourceSessionId}` !==
+                (identity.parentSessionId ?? identity.sessionId))) {
+        return { events: [], gaps: ["session_id_does_not_match_path"] };
+    }
+    if (identity.agentId !== null && string(record.agentId) !== identity.agentId)
+        return { events: [], gaps: ["agent_id_does_not_match_path"] };
+    const gaps = [];
+    if (record.timestamp !== undefined && timestamp(record) === null)
+        gaps.push("invalid_source_timestamp");
+    const events = [];
+    const meta = {
+        id: identity.runId,
+        parent_thread_id: identity.parentRunId,
+        cwd: string(record.cwd),
+        git: { branch: string(record.gitBranch) },
+        version: string(record.version),
+        agentId: identity.agentId,
+    };
+    events.push({
+        ...event(identity, record, 0, 0, "session_meta", meta, null, "session_meta"),
+        run: {
+            kind: "identity",
+            id: identity.runId,
+            parentId: identity.parentRunId,
+            ownStart: true,
+            startOrdinal: null,
+        },
+    });
+    if (recordType === "user") {
+        const message = object(record.message);
+        const content = message === null ? null : string(message.content);
+        if (message === null)
+            gaps.push("user_without_message");
+        else if (content !== null) {
+            events.push(event(identity, record, byteOffset, 1, "user_message", {
+                text: content,
+                record,
+            }));
+        }
+        else if (Array.isArray(message.content)) {
+            for (const [index, value] of message.content.entries()) {
+                const block = object(value);
+                if (block === null) {
+                    gaps.push("invalid_user_content_block");
+                    continue;
+                }
+                if (block.type === "tool_result") {
+                    const callId = string(block.tool_use_id);
+                    if (callId === null) {
+                        gaps.push("tool_result_without_call_id");
+                        continue;
+                    }
+                    events.push(event(identity, record, byteOffset, index + 1, "tool_result", {
+                        text: contentText(block.content),
+                        record,
+                    }, callId));
+                }
+                else {
+                    events.push(event(identity, record, byteOffset, index + 1, "user_message", {
+                        text: string(block.text) ?? contentText(block.content),
+                        record,
+                    }));
+                }
+            }
+        }
+        else
+            gaps.push("unsupported_user_content");
+    }
+    else if (recordType === "assistant") {
+        const message = object(record.message);
+        if (message === null || !Array.isArray(message.content))
+            gaps.push("assistant_without_content_blocks");
+        else {
+            for (const [index, value] of message.content.entries()) {
+                const block = object(value);
+                if (block === null) {
+                    gaps.push("invalid_assistant_content_block");
+                    continue;
+                }
+                const blockType = string(block.type);
+                const eventType = blockType === "text"
+                    ? "assistant_message"
+                    : blockType === "thinking" || blockType === "redacted_thinking"
+                        ? "reasoning"
+                        : blockType === "tool_use"
+                            ? "tool_call"
+                            : null;
+                if (eventType === null) {
+                    gaps.push(`unsupported_assistant_block:${blockType ?? "unknown"}`);
+                    continue;
+                }
+                const callId = eventType === "tool_call" ? string(block.id) : null;
+                if (eventType === "tool_call" && callId === null) {
+                    gaps.push("tool_call_without_call_id");
+                    continue;
+                }
+                events.push(event(identity, record, byteOffset, index + 1, eventType, {
+                    text: string(block.text) ?? string(block.thinking),
+                    name: string(block.name),
+                    record,
+                }, callId));
+            }
+            if (object(message.usage) !== null && string(message.id) !== null) {
+                events.push(event(identity, record, byteOffset, 9999, "token_usage_record", { model: string(message.model), usage: message.usage }, null, `usage:${message.id}`));
+            }
+        }
+    }
+    else if (recordType !== null && CONTEXT_RECORD_TYPES.has(recordType)) {
+        const attachment = object(record.attachment);
+        events.push(event(identity, record, byteOffset, 1, "source_record", {
+            sourceType: recordType,
+            subtype: string(record.subtype) ??
+                (attachment === null ? null : string(attachment.type)),
+            record,
+        }));
+    }
+    else
+        gaps.push(`unsupported_claude_record:${recordType ?? "unknown"}`);
+    const valid = [];
+    for (const candidate of events) {
+        const checked = parseTraceEventBatch({ events: [candidate] });
+        if (checked.success)
+            valid.push(candidate);
+        else
+            gaps.push(`invalid_normalized_event:${candidate.eventType}`);
+    }
+    return { events: valid, gaps };
+}

package/dist/clerk-device-auth.d.ts

@@ -1,4 +1,5 @@
-export declare function authenticateAndEnrollCollector(endpoint: URL, deviceNameValue: string, organizationId: string | null): Promise<Readonly<{
+import { type CollectorSource } from "iteration-trace-contracts";
+export declare function authenticateAndEnrollCollector(endpoint: URL, deviceNameValue: string, organizationId: string | null, source?: CollectorSource): Promise<Readonly<{
     token: string;
     deviceId: string;
     organizationName: string;

package/dist/clerk-device-auth.js

@@ -186,8 +186,10 @@ async function clerkDeviceSignIn(configuration) {
     await openBrowser(verificationUrl);
     return pollForAccessToken(endpoints.tokenUrl, configuration.clientId, challenge.device_code, challenge.expires_in, challenge.interval);
 }
-async function enrollDevice(endpoint, accessToken, deviceName, organizationId) {
+async function enrollDevice(endpoint, accessToken, deviceName, organizationId, source) {
     const body = { deviceName };
+    if (source === "claude")
+        body.source = source;
     if (organizationId !== null)
         body.organizationId = organizationId;
     const response = await fetch(apiRoute(endpoint, "./collector-auth/enroll"), {
@@ -248,7 +250,7 @@ async function chooseOrganization(organizations, hasMore) {
         prompt.close();
     }
 }
-export async function authenticateAndEnrollCollector(endpoint, deviceNameValue, organizationId) {
+export async function authenticateAndEnrollCollector(endpoint, deviceNameValue, organizationId, source = "codex") {
     const deviceName = z
         .string()
         .trim()
@@ -260,10 +262,10 @@ export async function authenticateAndEnrollCollector(endpoint, deviceNameValue,
     }
     const configuration = await loadOAuthConfiguration(endpoint);
     const clerkAccessToken = await clerkDeviceSignIn(configuration);
-    let result = await enrollDevice(endpoint, clerkAccessToken, deviceName.data, organizationId);
+    let result = await enrollDevice(endpoint, clerkAccessToken, deviceName.data, organizationId, source);
     if (result.status === "choose_organization") {
         const selectedOrganizationId = await chooseOrganization(result.organizations, result.hasMore);
-        result = await enrollDevice(endpoint, clerkAccessToken, deviceName.data, selectedOrganizationId);
+        result = await enrollDevice(endpoint, clerkAccessToken, deviceName.data, selectedOrganizationId, source);
     }
     if (result.status !== "enrolled") {
         throw new Error("The collector could not be assigned to that workspace.");

package/dist/cli.js

@@ -4,12 +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, 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 +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" },
@@ -49,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.",
             "",
@@ -58,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");
@@ -67,12 +71,13 @@ function usage(command) {
         "Iteration CLI",
         "",
         "Get started:",
-        "  iteration                 Connect Codex, or see its current activity",
+        "  iteration                 See connected sources or connect Codex",
         "",
         "Commands:",
         "  iteration connect codex   Connect Codex directly",
+        "  iteration connect claude  Connect Claude Code directly",
         "  iteration status          See scan, upload, and error details",
-        "  iteration disconnect codex      Stop collecting",
+        "  iteration disconnect codex|claude  Stop a source",
         "",
         "Run iteration connect codex --help for advanced setup options.",
     ].join("\n") + "\n");
@@ -92,22 +97,29 @@ 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`);
         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.");
     }
@@ -115,65 +127,75 @@ 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 is connected to ${enrollment.organizationName}. Existing sessions are importing and new activity is collected automatically. Run iteration to check progress.\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(`Codex is collecting again. Run iteration to check progress.${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 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 +207,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 +228,62 @@ 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 (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

@@ -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;
 }>>;