iteration-cli 0.4.4 → 0.5.0

package/dist/service.js

@@ -2,7 +2,7 @@ import { promises as fs } from "node:fs";
 import path from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 import { collectorTick, TraceUploadError } from "./collector.js";
-import { collectorPaths, ensureHistoryBackfill, ensurePrivateDirectory, healthSnapshot, loadConfig, saveHealth, } from "./storage.js";
+import { collectorSource, collectorPaths, ensureClaudeHistoryBackfill, ensureHistoryBackfill, ensurePrivateDirectory, healthSnapshot, loadConfig, saveHealth, } from "./storage.js";
 function errorCode(error) {
     if (error instanceof Error && "code" in error)
         return String(error.code);
@@ -57,7 +57,7 @@ export async function acquireCollectorLock(paths) {
             }
             try {
                 process.kill(lockPid, 0);
-                throw new CollectorLockBusyError("Codex collector is already running.");
+                throw new CollectorLockBusyError("Collector is already running.");
             }
             catch (processError) {
                 if (errorCode(processError) !== "ESRCH")
@@ -66,7 +66,7 @@ export async function acquireCollectorLock(paths) {
             }
         }
     }
-    throw new Error("Could not obtain the Codex collector lock.");
+    throw new Error("Could not obtain the collector lock.");
 }
 export async function waitForCollectorLock(paths) {
     for (let attempt = 0; attempt < 81; attempt += 1) {
@@ -84,7 +84,7 @@ export async function waitForCollectorLock(paths) {
     }
     throw new Error("Could not obtain the collector lock.");
 }
-export async function runCollector(directory) {
+export async function runCollector(directory, expectedSource) {
     const paths = collectorPaths(directory);
     const releaseLock = await acquireCollectorLock(paths);
     const controller = new AbortController();
@@ -94,6 +94,10 @@ export async function runCollector(directory) {
     let retryDelayMs = 5000;
     try {
         const config = await loadConfig(paths);
+        const source = collectorSource(config);
+        if (expectedSource !== undefined && expectedSource !== source) {
+            throw new Error(`Collector directory belongs to ${source}, not ${expectedSource}.`);
+        }
         const loadedHealth = await healthSnapshot(paths);
         let health = loadedHealth.health;
         if (loadedHealth.kind === "unavailable") {
@@ -103,7 +107,10 @@ export async function runCollector(directory) {
                 message: "Local collector status could not be read; collection continues.",
             }));
         }
-        await ensureHistoryBackfill(config.codexHome, paths);
+        if ("claudeHome" in config)
+            await ensureClaudeHistoryBackfill(config.claudeHome, paths);
+        else
+            await ensureHistoryBackfill(config.codexHome, paths);
         while (!controller.signal.aborted) {
             let acknowledgedAtMs = null;
             try {
@@ -124,6 +131,7 @@ export async function runCollector(directory) {
                 if (result.discovered > 0 || result.uploaded > 0) {
                     console.info(JSON.stringify({
                         level: "info",
+                        source,
                         discovered: result.discovered,
                         uploaded: result.uploaded,
                         outboxBytes: result.outboxBytes,
@@ -141,6 +149,7 @@ export async function runCollector(directory) {
                 };
                 console.error(JSON.stringify({
                     level: "error",
+                    source,
                     operation: "collector_tick",
                     errorName: error instanceof Error ? error.name : "UnknownError",
                     message: error instanceof Error

package/dist/status-view.d.ts

@@ -1,3 +1,4 @@
+import { type CollectorSource } from "iteration-trace-contracts";
 import type { CollectorHealth } from "./storage.js";
 type ScanProgress = Readonly<{
     kind: "waiting";
@@ -24,6 +25,6 @@ export type CliStatus = Readonly<{
     tracesUrl: string;
     logPath: string;
 }>;
-export declare function renderHome(status: CliStatus, nowMs?: number): string;
-export declare function renderDetailedStatus(status: CliStatus, nowMs?: number): string;
+export declare function renderHome(status: CliStatus, nowMs?: number, source?: CollectorSource): string;
+export declare function renderDetailedStatus(status: CliStatus, nowMs?: number, source?: CollectorSource): string;
 export {};

package/dist/status-view.js

@@ -1,3 +1,7 @@
+import { collectorSourceLabel, } from "iteration-trace-contracts";
+function sourceName(source) {
+    return collectorSourceLabel(source);
+}
 function safeWorkspaceName(value) {
     const cleaned = value
         ?.split("")
@@ -41,11 +45,11 @@ function relativeTime(atMs, nowMs) {
 function pendingDescription(status) {
     return `${status.pendingEvents} event${status.pendingEvents === 1 ? "" : "s"} (${readableBytes(status.pendingBytes)}) waiting on this Mac`;
 }
-function progressDescription(scan) {
+function progressDescription(scan, source) {
     if (scan.kind === "waiting")
         return "Local history is preparing to scan.";
     if (scan.totalBytes === 0)
-        return "No local Codex sessions found yet.";
+        return `No local ${sourceName(source)} sessions found yet.`;
     if (scan.scannedBytes >= scan.totalBytes)
         return `Local history scanned (${readableBytes(scan.totalBytes)}).`;
     const remainingBytes = scan.totalBytes - scan.scannedBytes;
@@ -54,9 +58,9 @@ function progressDescription(scan) {
     const percentage = Math.min(99, Math.floor((scan.scannedBytes / scan.totalBytes) * 100));
     return `About ${percentage}% of local history scanned (${readableBytes(scan.scannedBytes)} of ${readableBytes(scan.totalBytes)}).`;
 }
-function historyDescription(status) {
+function historyDescription(status, source) {
     if (status.health.historyCaughtUpAtMs === null) {
-        return progressDescription(status.scan);
+        return progressDescription(status.scan, source);
     }
     if (status.scan.kind === "waiting")
         return "History is preparing to scan.";
@@ -67,7 +71,8 @@ function historyDescription(status) {
         return "History imported; scanning current activity.";
     return `History imported; ${readableBytes(remainingBytes)} of new activity waiting to scan.`;
 }
-function failureDescription(status) {
+function failureDescription(status, source) {
+    const name = sourceName(source);
     const failure = status.health.lastFailure;
     if (failure === null) {
         throw new Error("A collector failure is required to describe it.");
@@ -76,7 +81,7 @@ function failureDescription(status) {
         const code = failure.status === null ? "HTTP error" : `HTTP ${failure.status}`;
         if (failure.status === 401 || failure.status === 403) {
             return {
-                heading: "Codex upload access needs attention",
+                heading: `${name} upload access needs attention`,
                 explanation: `Iteration denied this collector (${code}). Queued data stays on this Mac. Contact Iteration support to reconnect it safely.`,
             };
         }
@@ -84,51 +89,52 @@ function failureDescription(status) {
             failure.status < 500 &&
             failure.status !== 429) {
             return {
-                heading: "Codex uploads need attention",
+                heading: `${name} uploads need attention`,
                 explanation: `Iteration rejected an event batch (${code}). Check the collector log for details.`,
             };
         }
         return {
-            heading: "Codex uploads are delayed",
+            heading: `${name} uploads are delayed`,
             explanation: `Iteration could not accept an upload (${code}). Retrying automatically.`,
         };
     }
     if (failure.kind === "network") {
         return {
-            heading: "Codex uploads are delayed",
+            heading: `${name} uploads are delayed`,
             explanation: "Could not reach Iteration. Retrying automatically.",
         };
     }
     if (failure.kind === "response") {
         return {
-            heading: "Codex uploads need attention",
+            heading: `${name} uploads need attention`,
             explanation: "Iteration returned an unexpected upload response. Retrying automatically.",
         };
     }
     return {
-        heading: "Codex collector needs attention",
-        explanation: "A local error interrupted collection. See iteration status codex for details.",
+        heading: `${name} collector needs attention`,
+        explanation: `A local error interrupted collection. See iteration status ${source} for details.`,
     };
 }
-export function renderHome(status, nowMs = Date.now()) {
+export function renderHome(status, nowMs = Date.now(), source = "codex") {
+    const name = sourceName(source);
     if (status.kind === "not_connected") {
         return [
             "Iteration",
             "",
-            "Codex is not connected.",
-            "Run iteration connect codex to import your existing sessions.",
+            `${name} is not connected.`,
+            `Run iteration connect ${source} to import your existing sessions.`,
         ].join("\n");
     }
     if (status.kind === "needs_repair") {
         return [
             "Iteration",
             "",
-            "Codex connection needs repair",
+            `${name} connection needs repair`,
             "Local collector data exists, but its connection details are missing.",
             status.pendingBytes > 0
                 ? `${readableBytes(status.pendingBytes)} of queued data remains on this Mac.`
                 : "Existing local progress remains on this Mac.",
-            "Run iteration status codex for recovery details.",
+            `Run iteration status ${source} for recovery details.`,
         ].join("\n");
     }
     const workspaceName = safeWorkspaceName(status.workspaceName);
@@ -137,54 +143,54 @@ export function renderHome(status, nowMs = Date.now()) {
         "",
     ];
     if (!status.running) {
-        lines.push("Codex is stopped", "New sessions are not being collected.");
+        lines.push(`${name} is stopped`, "New sessions are not being collected.");
         if (status.pendingEvents > 0)
             lines.push(`${pendingDescription(status)}.`);
-        lines.push("Resume with iteration start codex.");
+        lines.push(`Resume with iteration start ${source}.`);
     }
     else if (!status.healthAvailable) {
-        lines.push("Codex is running; local status needs attention", "Upload history could not be read. Collection continues in the background.");
+        lines.push(`${name} is running; local status needs attention`, "Upload history could not be read. Collection continues in the background.");
         if (status.pendingEvents > 0)
             lines.push(`${pendingDescription(status)}.`);
-        lines.push("Details: iteration status codex");
+        lines.push(`Details: iteration status ${source}`);
     }
     else if (status.health.lastFailure !== null) {
-        const failure = failureDescription(status);
+        const failure = failureDescription(status, source);
         lines.push(failure.heading, failure.explanation);
         if (status.pendingEvents > 0)
             lines.push(`${pendingDescription(status)}.`);
         if (status.health.lastUploadAtMs !== null) {
             lines.push(`Last successful upload ${relativeTime(status.health.lastUploadAtMs, nowMs)}.`);
         }
-        lines.push("Details: iteration status codex");
+        lines.push(`Details: iteration status ${source}`);
     }
     else if (status.scan.kind === "waiting") {
-        lines.push("Codex is preparing your history", progressDescription(status.scan));
+        lines.push(`${name} is preparing your history`, progressDescription(status.scan, source));
     }
     else if (status.scan.kind === "scanning" &&
         status.scan.totalBytes > 0 &&
         status.scan.scannedBytes < status.scan.totalBytes &&
         status.health.historyCaughtUpAtMs === null) {
-        lines.push("Codex is importing existing sessions", historyDescription(status), "New activity is collected automatically.");
+        lines.push(`${name} is importing existing sessions`, historyDescription(status, source), "New activity is collected automatically.");
     }
     else if (status.scan.kind === "scanning" &&
         status.scan.totalBytes - status.scan.scannedBytes >= 1_000_000) {
-        lines.push("Codex is catching up with new activity", historyDescription(status));
+        lines.push(`${name} is catching up with new activity`, historyDescription(status, source));
         if (status.pendingEvents > 0)
             lines.push(`${pendingDescription(status)}.`);
     }
     else if (status.pendingEvents > 0) {
-        lines.push("Codex is uploading captured sessions", `${pendingDescription(status)}.`);
+        lines.push(`${name} is uploading captured sessions`, `${pendingDescription(status)}.`);
     }
     else if (status.scan.totalBytes === 0) {
-        lines.push("Codex is connected", "Waiting for Codex sessions on this Mac.");
+        lines.push(`${name} is connected`, `Waiting for ${name} sessions on this Mac.`);
     }
     else if (status.scan.kind === "scanning" &&
         status.scan.scannedBytes < status.scan.totalBytes) {
-        lines.push("Codex is collecting new activity", "Local history is imported; current activity is being scanned.");
+        lines.push(`${name} is collecting new activity`, "Local history is imported; current activity is being scanned.");
     }
     else {
-        lines.push("Codex is collecting", "Local scan is caught up and no uploads are waiting.", "New activity is collected automatically.");
+        lines.push(`${name} is collecting`, "Local scan is caught up and no uploads are waiting.", "New activity is collected automatically.");
     }
     if (status.running &&
         status.health.lastFailure === null &&
@@ -194,13 +200,14 @@ export function renderHome(status, nowMs = Date.now()) {
     lines.push("", `Explore traces  ${status.tracesUrl}`);
     return lines.join("\n");
 }
-export function renderDetailedStatus(status, nowMs = Date.now()) {
+export function renderDetailedStatus(status, nowMs = Date.now(), source = "codex") {
+    const name = sourceName(source);
     if (status.kind === "not_connected") {
-        return "Codex is not connected. Run iteration connect codex to connect.";
+        return `${name} is not connected. Run iteration connect ${source} to connect.`;
     }
     if (status.kind === "needs_repair") {
         return [
-            "Codex connection needs repair",
+            `${name} connection needs repair`,
             "Local collector data exists without its connection details.",
             `Queued data: ${readableBytes(status.pendingBytes)}`,
             `Restore the missing config from backup: ${status.configPath}`,
@@ -209,10 +216,10 @@ export function renderDetailedStatus(status, nowMs = Date.now()) {
     }
     const workspaceName = safeWorkspaceName(status.workspaceName);
     const lines = [
-        "Codex collector",
+        `${name} collector`,
         ...(workspaceName === null ? [] : [`Workspace: ${workspaceName}`]),
         `Background process: ${status.running ? "Running" : "Stopped"}`,
-        `History: ${historyDescription(status).replace(/^History /, "")}`,
+        `History: ${historyDescription(status, source).replace(/^History /, "")}`,
         `Uploads: ${status.pendingEvents === 0 ? "None waiting" : pendingDescription(status)}`,
     ];
     if (!status.healthAvailable) {
@@ -233,7 +240,7 @@ export function renderDetailedStatus(status, nowMs = Date.now()) {
         lines.push(`Last issue: ${label} (${relativeTime(failure.atMs, nowMs)})`, `Collector log: ${status.logPath}`);
     }
     if (!status.running)
-        lines.push("Resume: iteration start codex");
+        lines.push(`Resume: iteration start ${source}`);
     lines.push(`Explore traces: ${status.tracesUrl}`);
     return lines.join("\n");
 }

package/dist/storage.d.ts

@@ -1,11 +1,18 @@
-import { type TraceEvent } from "iteration-trace-contracts";
-export type CollectorConfig = Readonly<{
+import { type CollectorSource, type TraceEvent } from "iteration-trace-contracts";
+type CollectorConnection = Readonly<{
     endpoint: string;
     token: string;
-    codexHome: string;
     dataDirectory: string;
     organizationName?: string;
 }>;
+export type CollectorConfig = (CollectorConnection & Readonly<{
+    codexHome: string;
+}>) | (CollectorConnection & Readonly<{
+    source: "claude";
+    claudeHome: string;
+}>);
+export declare function collectorSource(config: CollectorConfig): CollectorSource;
+export declare function collectorSourceDirectory(config: CollectorConfig): string;
 export type CollectorState = Readonly<{
     cursors: Readonly<Record<string, number>>;
     skipping: readonly string[];
@@ -37,9 +44,10 @@ export type CollectorPaths = Readonly<{
     historyBackfill: string;
     health: string;
 }>;
+export declare function defaultCollectorDirectory(source: CollectorSource): string;
 export declare function validateCollectorEndpoint(endpoint: string): URL;
 export declare function collectorPaths(directory?: string): CollectorPaths;
-export declare function assertFreshCollectorDirectory(paths: CollectorPaths): Promise<void>;
+export declare function assertFreshCollectorDirectory(paths: CollectorPaths, source?: CollectorSource): Promise<void>;
 export declare function ensurePrivateDirectory(directory: string): Promise<void>;
 export declare function saveConfig(config: CollectorConfig, paths: CollectorPaths): Promise<void>;
 export declare function loadHealth(paths: CollectorPaths): Promise<CollectorHealth>;
@@ -53,23 +61,26 @@ export declare function pendingEventIds(paths: CollectorPaths): Promise<Set<stri
 export declare function appendEvents(events: readonly TraceEvent[], paths: CollectorPaths): Promise<void>;
 export declare function nextBatch(paths: CollectorPaths, maxBytes: number): Promise<readonly TraceEvent[]>;
 export declare function acknowledgeEvents(acknowledgedIds: ReadonlySet<string>, paths: CollectorPaths): Promise<void>;
-export declare function initializeState(codexHome: string, paths: CollectorPaths, includeHistory: boolean): Promise<void>;
-export declare function prepareInitialState(codexHome: string, includeHistory: boolean): Promise<CollectorState>;
+export declare function initializeState(source: CollectorSource, home: string, paths: CollectorPaths, includeHistory: boolean): Promise<void>;
+export declare function prepareSourceInitialState(source: CollectorSource, home: string, includeHistory: boolean): Promise<CollectorState>;
 export declare function ensureStartableState(config: CollectorConfig, paths: CollectorPaths): Promise<boolean>;
 export declare function ensureHistoryBackfill(codexHome: string, paths: CollectorPaths): Promise<boolean>;
-export declare function historyScanProgress(codexHome: string, paths: CollectorPaths): Promise<Readonly<{
+export declare function ensureClaudeHistoryBackfill(claudeHome: string, paths: CollectorPaths): Promise<boolean>;
+export declare function historyScanProgress(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
     kind: "waiting";
 } | {
     kind: "scanning";
     scannedBytes: number;
     totalBytes: number;
 }>>;
-export declare function resetHistoryCursors(codexHome: string, paths: CollectorPaths): Promise<Readonly<{
+export declare function resetHistoryCursors(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
     files: number;
     bytes: number;
 }>>;
-export declare function historyImportSize(codexHome: string): Promise<Readonly<{
+export declare function historyImportSize(home: string, source?: CollectorSource): Promise<Readonly<{
     files: number;
     bytes: number;
 }>>;
-export declare function rolloutFiles(root: string): Promise<string[]>;
+export declare function claudeFiles(root: string): Promise<string[]>;
+export declare function sourceFiles(source: CollectorSource, home: string): Promise<string[]>;
+export {};