iteration-cli 0.7.3 → 0.8.1

package/dist/status-view.d.ts

@@ -23,6 +23,7 @@ export type CliStatus = Readonly<{
     health: CollectorHealth;
     healthAvailable: boolean;
     turnSummaryNeedsApproval: boolean;
+    hookFailureAtMs?: number | null;
     tracesUrl: string;
     logPath: string;
 }>;

package/dist/status-view.js

@@ -149,6 +149,10 @@ export function renderHome(status, nowMs = Date.now(), source = "codex") {
             lines.push(`${pendingDescription(status)}.`);
         lines.push(`Resume with iteration start ${source}.`);
     }
+    else if (status.hookFailureAtMs !== null &&
+        status.hookFailureAtMs !== undefined) {
+        lines.push(`${name} hook capture needs attention`, `A Cursor hook failed ${relativeTime(status.hookFailureAtMs, nowMs)}. Some data may be missing. See iteration status cursor.`);
+    }
     else if (!status.healthAvailable) {
         lines.push(`${name} is running; local status needs attention`, "Upload history could not be read. Collection continues in the background.");
         if (status.pendingEvents > 0)
@@ -242,6 +246,8 @@ export function renderDetailedStatus(status, nowMs = Date.now(), source = "codex
                     : "Local collector error";
         lines.push(`Last issue: ${label} (${relativeTime(failure.atMs, nowMs)})`, `Collector log: ${status.logPath}`);
     }
+    if (status.hookFailureAtMs !== null && status.hookFailureAtMs !== undefined)
+        lines.push(`Last Cursor hook capture failure: ${relativeTime(status.hookFailureAtMs, nowMs)}. Some data may be missing; inspect Cursor hook logs.`);
     if (status.turnSummaryNeedsApproval)
         lines.push(CODEX_APPROVAL_STEP);
     if (!status.running)

package/dist/storage.d.ts

@@ -11,6 +11,9 @@ export type CollectorConfig = (CollectorConnection & Readonly<{
 }>) | (CollectorConnection & Readonly<{
     source: "claude";
     claudeHome: string;
+}>) | (CollectorConnection & Readonly<{
+    source: "cursor";
+    cursorHome: string;
 }>);
 export declare function collectorSource(config: CollectorConfig): CollectorSource;
 export declare function collectorSourceDirectory(config: CollectorConfig): string;
@@ -41,6 +44,7 @@ export type CollectorPaths = Readonly<{
     config: string;
     state: string;
     outbox: string;
+    redactionMarker: string;
     lock: string;
     historyBackfill: string;
     health: string;
@@ -60,6 +64,7 @@ export declare function saveState(state: CollectorState, paths: CollectorPaths):
 export declare function outboxSize(paths: CollectorPaths): Promise<number>;
 export declare function pendingEventIds(paths: CollectorPaths): Promise<Set<string>>;
 export declare function appendEvents(events: readonly TraceEvent[], paths: CollectorPaths): Promise<void>;
+export declare function redactPendingOutbox(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(source: CollectorSource, home: string, paths: CollectorPaths, includeHistory: boolean): Promise<void>;
@@ -67,6 +72,7 @@ export declare function prepareSourceInitialState(source: CollectorSource, home:
 export declare function ensureStartableState(config: CollectorConfig, paths: CollectorPaths): Promise<boolean>;
 export declare function ensureHistoryBackfill(codexHome: string, paths: CollectorPaths): Promise<boolean>;
 export declare function ensureClaudeHistoryBackfill(claudeHome: string, paths: CollectorPaths): Promise<boolean>;
+export declare function ensureCursorHistoryBackfill(cursorHome: string, paths: CollectorPaths): Promise<boolean>;
 export declare function historyScanProgress(home: string, paths: CollectorPaths, source?: CollectorSource): Promise<Readonly<{
     kind: "waiting";
 } | {
@@ -84,4 +90,5 @@ export declare function historyImportSize(home: string, source?: CollectorSource
 }>>;
 export declare function claudeFiles(root: string): Promise<string[]>;
 export declare function sourceFiles(source: CollectorSource, home: string): Promise<string[]>;
+export declare function cursorFiles(root: string): Promise<string[]>;
 export {};

package/dist/storage.js

@@ -1,16 +1,25 @@
 import { once } from "node:events";
-import { createWriteStream, promises as fs } from "node:fs";
+import { createReadStream, createWriteStream, promises as fs } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline";
 import { MAX_TRACE_EVENTS_PER_BATCH, parseTraceEventBatch, } from "iteration-trace-contracts";
 import * as z from "zod";
+import { redactTraceEvent } from "./redact-trace.js";
 const MAX_OUTBOX_BYTES = 64 * 1024 * 1024;
 export function collectorSource(config) {
-    return "claudeHome" in config ? "claude" : "codex";
+    return "cursorHome" in config
+        ? "cursor"
+        : "claudeHome" in config
+            ? "claude"
+            : "codex";
 }
 export function collectorSourceDirectory(config) {
-    return "claudeHome" in config ? config.claudeHome : config.codexHome;
+    return "cursorHome" in config
+        ? config.cursorHome
+        : "claudeHome" in config
+            ? config.claudeHome
+            : config.codexHome;
 }
 const connectionSchema = {
     endpoint: z.string(),
@@ -28,6 +37,13 @@ const configSchema = z.union([
         claudeHome: z.string(),
     })
         .strict(),
+    z
+        .object({
+        ...connectionSchema,
+        source: z.literal("cursor"),
+        cursorHome: z.string(),
+    })
+        .strict(),
 ]);
 const stateSchema = z
     .object({
@@ -51,6 +67,7 @@ const healthSchema = z
         .nullable(),
 })
     .strict();
+const redactionMarkerSchema = z.object({ version: z.literal(1) }).strict();
 function parseOutboxEvent(line) {
     let decoded;
     try {
@@ -101,6 +118,7 @@ export function collectorPaths(directory = defaultCollectorDirectory("codex")) {
         config: path.join(directory, "config.json"),
         state: path.join(directory, "state.json"),
         outbox: path.join(directory, "outbox.jsonl"),
+        redactionMarker: path.join(directory, "redaction.json"),
         lock: path.join(directory, "collector.lock"),
         historyBackfill: path.join(directory, "history-backfill.json"),
         health: path.join(directory, "health.json"),
@@ -315,6 +333,72 @@ export async function appendEvents(events, paths) {
         await handle.close();
     }
 }
+export async function redactPendingOutbox(paths) {
+    let marker;
+    try {
+        marker = await fs.readFile(paths.redactionMarker, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            marker = null;
+        else
+            throw error;
+    }
+    if (marker !== null) {
+        let decoded;
+        try {
+            decoded = JSON.parse(marker);
+        }
+        catch {
+            throw new Error("Collector redaction marker is not valid JSON.");
+        }
+        if (!redactionMarkerSchema.safeParse(decoded).success)
+            throw new Error("Collector redaction marker has an invalid shape.");
+        return;
+    }
+    const size = await outboxSize(paths);
+    if (size > MAX_OUTBOX_BYTES)
+        throw new Error("Trace outbox exceeds its configured capacity.");
+    if (size > 0) {
+        const temporary = `${paths.outbox}.${process.pid}.redacting`;
+        const output = await fs.open(temporary, "w", 0o600);
+        try {
+            const lines = createInterface({
+                input: createReadStream(paths.outbox, { encoding: "utf8" }),
+                crlfDelay: Infinity,
+            });
+            for await (const line of lines) {
+                const event = await redactTraceEvent(parseOutboxEvent(line));
+                await output.writeFile(`${JSON.stringify(event)}\n`, "utf8");
+            }
+            await output.sync();
+        }
+        catch (error) {
+            await output.close();
+            await fs.rm(temporary, { force: true });
+            throw error;
+        }
+        await output.close();
+        try {
+            if ((await fs.stat(temporary)).size > MAX_OUTBOX_BYTES)
+                throw new Error("Redacted trace outbox exceeds its configured capacity.");
+            await fs.rename(temporary, paths.outbox);
+            const directory = await fs.open(path.dirname(paths.outbox), "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+        catch (error) {
+            await fs.rm(temporary, { force: true });
+            throw error;
+        }
+    }
+    await ensurePrivateDirectory(path.dirname(paths.redactionMarker));
+    await writeJsonAtomic(paths.redactionMarker, { version: 1 });
+}
 export async function nextBatch(paths, maxBytes) {
     if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) {
         throw new Error("Maximum upload batch size must be a positive integer.");
@@ -492,6 +576,18 @@ export async function ensureClaudeHistoryBackfill(claudeHome, paths) {
     await writeJsonAtomic(paths.historyBackfill, { version: 1 });
     return true;
 }
+export async function ensureCursorHistoryBackfill(cursorHome, paths) {
+    const version = await readHistoryBackfillVersion(paths);
+    if (version !== null && version >= 1)
+        return false;
+    const state = await loadState(paths);
+    if (!state.initialized || state.sourceDirectory !== path.resolve(cursorHome))
+        throw new Error("Collector state does not match the Cursor directory; reconnect Cursor before uploading.");
+    await cursorFiles(path.join(cursorHome, "projects"));
+    await saveState({ ...state, cursors: {}, skipping: [] }, paths);
+    await writeJsonAtomic(paths.historyBackfill, { version: 1 });
+    return true;
+}
 export async function historyScanProgress(home, paths, source = "codex") {
     if ((await readHistoryBackfillVersion(paths)) === null)
         return { kind: "waiting" };
@@ -677,6 +773,32 @@ export function sourceFiles(source, home) {
         return rolloutFiles(path.join(directory, "sessions"));
     if (source === "claude")
         return claudeFiles(path.join(directory, "projects"));
+    if (source === "cursor")
+        return cursorFiles(path.join(directory, "projects"));
     const unhandled = source;
     throw new Error(`Unsupported collector source: ${unhandled}`);
 }
+export async function cursorFiles(root) {
+    const files = [];
+    for (const project of await directoryEntries(root)) {
+        if (!project.isDirectory())
+            continue;
+        const transcripts = path.join(root, project.name, "agent-transcripts");
+        for (const conversation of await directoryEntries(transcripts)) {
+            if (!conversation.isDirectory())
+                continue;
+            const filename = path.join(transcripts, conversation.name, `${conversation.name}.jsonl`);
+            if ((await fs.stat(filename).catch((error) => {
+                if (error instanceof Error &&
+                    "code" in error &&
+                    error.code === "ENOENT")
+                    return null;
+                throw error;
+            }))?.isFile())
+                files.push(filename);
+            if (files.length > 10_000)
+                throw new Error("Cursor session file count exceeds the scan limit.");
+        }
+    }
+    return files.sort();
+}

package/dist/turn-summary.js

@@ -55,6 +55,8 @@ function hookCommand(paths) {
     return `/bin/sh ${shellQuote(paths.script)}`;
 }
 function agentHookFile(config) {
+    if ("cursorHome" in config)
+        throw new Error("Cursor uses its own trace hooks.");
     return "claudeHome" in config
         ? path.join(config.claudeHome, "settings.json")
         : path.join(config.codexHome, "hooks.json");
@@ -337,7 +339,7 @@ function codexTrustedHash(configToml, key) {
     return trustedHash;
 }
 export async function codexTurnSummaryApproval(config) {
-    if ("claudeHome" in config)
+    if ("claudeHome" in config || "cursorHome" in config)
         return "approved";
     const filename = agentHookFile(config);
     const { file } = await readHookFile(filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iteration-cli",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "type": "module",
   "repository": {
     "type": "git",
@@ -17,8 +17,10 @@
     "iteration": "./dist/cli.js"
   },
   "dependencies": {
+    "@secretlint/core": "13.0.6",
+    "@secretlint/secretlint-rule-preset-recommend": "13.0.6",
     "zod": "4.6.4",
-    "iteration-trace-contracts": "0.6.0"
+    "iteration-trace-contracts": "0.7.0"
   },
   "scripts": {
     "build": "pnpm --filter iteration-trace-contracts build && tsc -p tsconfig.json"