iteration-cli 0.7.3 → 0.8.1

package/dist/cursor-hooks.js

@@ -0,0 +1,163 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as z from "zod";
+import { ensurePrivateDirectory } from "./storage.js";
+export const CURSOR_HOOKS = [
+    "sessionStart",
+    "beforeSubmitPrompt",
+    "preToolUse",
+    "postToolUse",
+    "postToolUseFailure",
+    "afterAgentThought",
+    "afterAgentResponse",
+    "preCompact",
+    "stop",
+    "subagentStart",
+    "subagentStop",
+    "sessionEnd",
+];
+export function cursorHookDirectory(dataDirectory) {
+    return path.join(dataDirectory, "cursor-hooks");
+}
+export function cursorHookFailurePath(dataDirectory) {
+    return path.join(dataDirectory, "cursor-hook-failure.json");
+}
+export async function cursorHookFailureAtMs(dataDirectory) {
+    let contents;
+    try {
+        contents = await fs.readFile(cursorHookFailurePath(dataDirectory), "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    let decoded;
+    try {
+        decoded = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error("Cursor hook failure status is invalid.", { cause: error });
+    }
+    const parsed = z
+        .object({ atMs: z.number().int().min(0) })
+        .strict()
+        .safeParse(decoded);
+    if (!parsed.success)
+        throw new Error("Cursor hook failure status is invalid.");
+    return parsed.data.atMs;
+}
+function shellQuote(value) {
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function hookCommand(hook, dataDirectory) {
+    const entry = fileURLToPath(new URL("./cursor-hook-entry.js", import.meta.url));
+    return `${shellQuote(process.execPath)} ${shellQuote(entry)} ${shellQuote(hook)} ${shellQuote(dataDirectory)}`;
+}
+const hookEntrySchema = z.object({ command: z.string().optional() }).loose();
+const hookFileSchema = z
+    .object({
+    version: z.literal(1).optional(),
+    hooks: z.record(z.string(), z.array(hookEntrySchema)).optional(),
+})
+    .loose();
+async function readHooks(filename) {
+    let contents;
+    let mode = 0o600;
+    try {
+        contents = await fs.readFile(filename, "utf8");
+        mode = (await fs.stat(filename)).mode & 0o777;
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return { file: {}, mode };
+        throw new Error(`Could not read Cursor hooks at ${filename}.`, {
+            cause: error,
+        });
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(contents);
+    }
+    catch (error) {
+        throw new Error(`Cursor hooks at ${filename} are not valid JSON.`, {
+            cause: error,
+        });
+    }
+    const checked = hookFileSchema.safeParse(parsed);
+    if (!checked.success)
+        throw new Error(`Cursor hooks at ${filename} have an unexpected shape.`);
+    return { file: checked.data, mode };
+}
+async function writeHooks(filename, file, mode) {
+    await ensurePrivateDirectory(path.dirname(filename));
+    const target = await fs.realpath(filename).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return filename;
+        throw error;
+    });
+    const temporary = `${target}.iteration-${process.pid}.tmp`;
+    const handle = await fs.open(temporary, "w", mode);
+    try {
+        await handle.writeFile(`${JSON.stringify(file, null, 2)}\n`, "utf8");
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+    await fs.rename(temporary, target);
+}
+function entries(value) {
+    return value ?? [];
+}
+export async function installCursorHooks(cursorHome, dataDirectory) {
+    await ensurePrivateDirectory(cursorHookDirectory(dataDirectory));
+    const filename = path.join(cursorHome, "hooks.json");
+    const { file, mode } = await readHooks(filename);
+    const hooks = { ...file.hooks };
+    for (const hook of CURSOR_HOOKS) {
+        const command = hookCommand(hook, dataDirectory);
+        const existing = entries(hooks[hook]);
+        if (!existing.some((entry) => entry.command === command))
+            hooks[hook] = [...existing, { command }];
+    }
+    await writeHooks(filename, { ...file, version: 1, hooks }, mode);
+}
+export async function uninstallCursorHooks(cursorHome, dataDirectory) {
+    const filename = path.join(cursorHome, "hooks.json");
+    const { file, mode } = await readHooks(filename);
+    const hooks = { ...file.hooks };
+    let changed = false;
+    for (const hook of CURSOR_HOOKS) {
+        const existing = entries(hooks[hook]);
+        const remaining = existing.filter((entry) => entry.command !== hookCommand(hook, dataDirectory));
+        if (remaining.length !== existing.length) {
+            changed = true;
+            if (remaining.length === 0)
+                delete hooks[hook];
+            else
+                hooks[hook] = remaining;
+        }
+    }
+    if (changed)
+        await writeHooks(filename, { ...file, hooks }, mode);
+}
+export async function cursorHookFiles(dataDirectory) {
+    const directory = cursorHookDirectory(dataDirectory);
+    let names;
+    try {
+        names = await fs.readdir(directory);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return [];
+        throw error;
+    }
+    if (names.length > 10_000)
+        throw new Error("Cursor hook queue exceeds the scan limit.");
+    return names
+        .filter((name) => /^[0-9a-f-]+\.jsonl$/i.test(name))
+        .sort()
+        .map((name) => path.join(directory, name));
+}

package/dist/cursor-transcript.d.ts

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

package/dist/cursor-transcript.js

@@ -0,0 +1,294 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import * as z from "zod";
+import { parseTraceEventBatch, } from "iteration-trace-contracts";
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function record(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 nonnegativeInteger(value) {
+    const parsed = z
+        .number()
+        .int()
+        .min(0)
+        .max(Number.MAX_SAFE_INTEGER)
+        .safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+function event(conversationId, filename, byteOffset, index, eventType, payload, callId = null, occurredAt = null) {
+    const hash = createHash("sha256")
+        .update(`${filename}:${byteOffset}:${index}:${eventType}`)
+        .digest("hex");
+    return {
+        eventId: `${String(index).padStart(4, "0")}:${hash}`,
+        sessionId: `cursor:${conversationId}`,
+        sequence: byteOffset * 1000 + index,
+        callId,
+        projectId: null,
+        occurredAt,
+        eventType,
+        payload,
+    };
+}
+export function parseCursorTranscriptLine(line, filename, byteOffset) {
+    const conversationId = path.basename(filename, ".jsonl");
+    if (!UUID.test(conversationId) ||
+        path.basename(path.dirname(filename)) !== conversationId)
+        return { events: [], gaps: ["invalid_cursor_transcript_path"] };
+    let decoded;
+    try {
+        decoded = JSON.parse(line);
+    }
+    catch {
+        return { events: [], gaps: ["malformed_jsonl_record"] };
+    }
+    const source = record(decoded);
+    if (source === null)
+        return { events: [], gaps: ["record_is_not_an_object"] };
+    const events = [];
+    const gaps = [];
+    if (byteOffset === 0) {
+        events.push({
+            ...event(conversationId, filename, 0, 0, "session_meta", {
+                id: conversationId,
+                transcript_path: filename,
+            }),
+            run: {
+                kind: "identity",
+                id: conversationId,
+                parentId: null,
+                ownStart: true,
+                startOrdinal: null,
+            },
+        });
+    }
+    const role = string(source.role);
+    if (role === "user" || role === "assistant") {
+        const message = record(source.message);
+        if (message === null || !Array.isArray(message.content))
+            gaps.push("cursor_message_without_content");
+        else {
+            for (const [index, value] of message.content.entries()) {
+                const block = record(value);
+                if (block === null) {
+                    gaps.push("invalid_cursor_content_block");
+                    continue;
+                }
+                const type = string(block.type);
+                const eventType = type === "tool_use"
+                    ? "tool_call"
+                    : type === "thinking"
+                        ? "reasoning"
+                        : type === "text"
+                            ? role === "user"
+                                ? "user_message"
+                                : "assistant_message"
+                            : "source_record";
+                events.push(event(conversationId, filename, byteOffset, index + 1, eventType, {
+                    text: string(block.text) ?? string(block.thinking),
+                    name: string(block.name),
+                    input: block.input ?? null,
+                    sourceType: type,
+                    record: source,
+                }, string(block.id)));
+                if (type !== "text" && type !== "tool_use" && type !== "thinking")
+                    gaps.push(`unsupported_cursor_content_block:${type ?? "unknown"}`);
+            }
+        }
+    }
+    else if (source.type === "turn_ended") {
+        events.push(event(conversationId, filename, byteOffset, 1, source.status === "success" ? "turn_complete" : "turn_aborted", { record: source }));
+    }
+    else {
+        gaps.push(`unsupported_cursor_record:${string(source.type) ?? "unknown"}`);
+        events.push(event(conversationId, filename, byteOffset, 1, "source_record", {
+            sourceType: string(source.type),
+            record: source,
+        }));
+    }
+    return validated(events, gaps);
+}
+export function parseCursorHookLine(line, filename) {
+    let decoded;
+    try {
+        decoded = JSON.parse(line);
+    }
+    catch {
+        return { events: [], gaps: ["malformed_cursor_hook_record"] };
+    }
+    const wrapper = record(decoded);
+    const input = wrapper === null ? null : record(wrapper.input);
+    const conversationId = input === null ? null : string(input.conversation_id);
+    const hook = wrapper === null ? null : string(wrapper.hook);
+    const capturedAt = wrapper === null ? null : string(wrapper.capturedAt);
+    if (wrapper?.kind === "subagent_transcript_chunk") {
+        const subagent = record(wrapper.subagent);
+        const part = nonnegativeInteger(subagent?.part);
+        const totalParts = nonnegativeInteger(subagent?.totalParts);
+        if (conversationId === null ||
+            !UUID.test(conversationId) ||
+            capturedAt === null ||
+            Number.isNaN(Date.parse(capturedAt)) ||
+            subagent === null ||
+            part === null ||
+            totalParts === null ||
+            part < 1 ||
+            part > totalParts ||
+            string(subagent.base64) === null)
+            return { events: [], gaps: ["invalid_cursor_subagent_transcript_chunk"] };
+        const transcriptBytes = nonnegativeInteger(wrapper.transcriptBytes) ?? 0;
+        const candidate = event(conversationId, filename, transcriptBytes, part, "source_record", {
+            sourceType: "cursor_subagent_transcript",
+            text: string(subagent.text),
+            base64: string(subagent.base64),
+            path: string(subagent.path),
+            part,
+            totalParts,
+            parent_conversation_id: string(input?.parent_conversation_id),
+            subagent_id: string(input?.subagent_id),
+        }, null, capturedAt);
+        const hash = candidate.eventId.split(":").at(-1);
+        return validated([
+            {
+                ...candidate,
+                sequence: transcriptBytes * 1000 + 500,
+                eventId: `${String(Date.parse(capturedAt)).padStart(13, "0")}:${String(2000 + part).padStart(4, "0")}:${hash}`,
+            },
+        ], []);
+    }
+    if (input === null ||
+        conversationId === null ||
+        !UUID.test(conversationId) ||
+        hook === null ||
+        capturedAt === null ||
+        Number.isNaN(Date.parse(capturedAt)))
+        return { events: [], gaps: ["invalid_cursor_hook_record"] };
+    const transcriptBytes = wrapper?.transcriptBytes;
+    const sequence = nonnegativeInteger(transcriptBytes) ?? 0;
+    const events = [];
+    if (hook === "beforeSubmitPrompt" || hook === "sessionStart") {
+        const roots = Array.isArray(input.workspace_roots)
+            ? input.workspace_roots
+            : [];
+        events.push({
+            ...event(conversationId, filename, sequence, 0, "session_meta", {
+                id: conversationId,
+                cwd: string(roots[0]),
+                version: string(input.cursor_version),
+                model: string(input.model),
+                transcript_path: string(input.transcript_path),
+            }, null, capturedAt),
+            run: {
+                kind: "identity",
+                id: conversationId,
+                parentId: null,
+                ownStart: true,
+                startOrdinal: null,
+            },
+        });
+    }
+    const rawText = JSON.stringify(input);
+    if (Buffer.byteLength(rawText, "utf8") <= 500_000) {
+        events.push(event(conversationId, filename, sequence, 1, "source_record", {
+            sourceType: `cursor_hook:${hook}`,
+            record: input,
+        }, null, capturedAt));
+    }
+    else {
+        const chunks = splitText(rawText);
+        for (const [index, text] of chunks.entries())
+            events.push(event(conversationId, filename, sequence, index + 1, "source_record", {
+                sourceType: `cursor_hook:${hook}`,
+                text,
+                part: index + 1,
+                totalParts: chunks.length,
+            }, null, capturedAt));
+    }
+    const next = events.length + 1;
+    if (hook === "preToolUse") {
+        events.push(event(conversationId, filename, sequence, next, "tool_call", {
+            name: string(input.tool_name),
+            input: input.tool_input ?? null,
+        }, string(input.tool_use_id), capturedAt));
+    }
+    if (hook === "postToolUse" || hook === "postToolUseFailure") {
+        const output = string(input.tool_output) ??
+            string(input.error_message) ??
+            string(input.error) ??
+            (input.tool_output === undefined && input.error === undefined
+                ? null
+                : JSON.stringify(input.tool_output ?? input.error));
+        const chunks = output === null ? [null] : splitText(output);
+        for (const [index, text] of chunks.entries())
+            events.push(event(conversationId, filename, sequence, next + index, "tool_result", {
+                text,
+                name: string(input.tool_name),
+                part: index + 1,
+                totalParts: chunks.length,
+            }, string(input.tool_use_id), capturedAt));
+    }
+    else if (hook === "afterAgentThought") {
+        events.push(event(conversationId, filename, sequence, next, "reasoning", {
+            text: string(input.text) ?? string(input.thought),
+        }, null, capturedAt));
+    }
+    else if (hook === "afterAgentResponse" &&
+        (input.usage !== undefined ||
+            input.input_tokens !== undefined ||
+            input.output_tokens !== undefined)) {
+        events.push(event(conversationId, filename, sequence, next, "token_usage_record", {
+            model: string(input.model),
+            usage: input.usage ?? {
+                input_tokens: input.input_tokens ?? null,
+                output_tokens: input.output_tokens ?? null,
+                cache_read_tokens: input.cache_read_tokens ?? null,
+                cache_write_tokens: input.cache_write_tokens ?? null,
+            },
+        }, null, capturedAt));
+    }
+    const capturedAtMs = Date.parse(capturedAt);
+    const ordered = events.map((candidate, index) => {
+        const digest = candidate.eventId.split(":").at(-1);
+        const thought = candidate.eventType === "reasoning"
+            ? createHash("sha256")
+                .update(`${conversationId}:${string(input.generation_id)?.slice(0, 36) ?? ""}:${candidate.payload.text}`)
+                .digest("hex")
+            : null;
+        return {
+            ...candidate,
+            sequence: sequence * 1000 + 500,
+            eventId: thought === null
+                ? `${String(capturedAtMs).padStart(13, "0")}:${String(index).padStart(4, "0")}:${digest}`
+                : `thought:${thought}`,
+        };
+    });
+    return validated(ordered, []);
+}
+function splitText(value) {
+    if (value.length === 0)
+        return [""];
+    const chunks = [];
+    for (let start = 0; start < value.length;) {
+        let end = Math.min(start + 250_000, value.length);
+        if (end < value.length && /[\uD800-\uDBFF]/u.test(value[end - 1]))
+            end -= 1;
+        chunks.push(value.slice(start, end));
+        start = end;
+    }
+    return chunks;
+}
+function validated(events, gaps) {
+    const valid = [];
+    for (const candidate of events) {
+        if (parseTraceEventBatch({ events: [candidate] }).success)
+            valid.push(candidate);
+        else
+            gaps.push(`invalid_normalized_event:${candidate.eventType}`);
+    }
+    return { events: valid, gaps };
+}

package/dist/redact-trace.d.ts

@@ -0,0 +1,2 @@
+import type { TraceEvent } from "iteration-trace-contracts";
+export declare function redactTraceEvent(event: TraceEvent): Promise<TraceEvent>;

package/dist/redact-trace.js

@@ -0,0 +1,182 @@
+import { lintSource } from "@secretlint/core";
+import { rules as recommendedRules } from "@secretlint/secretlint-rule-preset-recommend";
+import * as z from "zod";
+const REDACTED = "[REDACTED]";
+const secretlintConfig = {
+    rules: recommendedRules
+        .filter((rule) => rule.meta.id !== "@secretlint/secretlint-rule-filter-comments")
+        .map((rule) => ({ id: rule.meta.id, rule })),
+};
+const assignment = /\b([A-Za-z][A-Za-z0-9_-]{0,79})["']?\s*[:=]\s*(?:"((?:\\.|[^"\\])*)"|'((?:\\.|[^'\\])*)'|([^\s"'`,;}&]+))/g;
+const authorization = /\b(?:authorization|proxy-authorization)["']?\s*:\s*["']?(?:Bearer|Basic)\s+([A-Za-z0-9._~+/-]+={0,2})/gi;
+const privateKey = /-----BEGIN ((?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY)-----[\s\S]*?-----END \1-----/g;
+function normalizedKey(key) {
+    return key
+        .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+        .replace(/[^A-Za-z0-9]+/g, "_")
+        .toLowerCase();
+}
+function sensitiveKey(key) {
+    const normalized = normalizedKey(key);
+    if (/^(?:next_public|public|vite|react_app)_/.test(normalized))
+        return false;
+    return (/(?:^|_)(?:secret|password|passwd|credential)(?:_|$)/.test(normalized) ||
+        /(?:^|_)(?:api_key|private_key|database_url|db_url|dsn|connection_string|authorization|proxy_authorization|auth_header|cookie|set_cookie|token)$/.test(normalized));
+}
+function placeholder(value) {
+    const trimmed = value.trim();
+    return (trimmed === REDACTED ||
+        /^(?:<[^>]+>|\$\{[^}]+\}|\*+|redacted|placeholder|example|changeme|undefined|null)$/i.test(trimmed) ||
+        /^(?:process\.env|env)\.[A-Za-z0-9_]+$/.test(trimmed));
+}
+function addRange(ranges, start, end, length) {
+    if (!Number.isSafeInteger(start) ||
+        !Number.isSafeInteger(end) ||
+        start < 0 ||
+        end > length ||
+        start >= end) {
+        throw new Error("Local trace secret scanner returned an invalid location.");
+    }
+    ranges.push({ start, end });
+}
+function textRanges(value) {
+    const ranges = [];
+    for (const match of value.matchAll(assignment)) {
+        const key = match[1];
+        const candidate = match[2] ?? match[3] ?? match[4];
+        if (key === undefined ||
+            candidate === undefined ||
+            candidate.length === 0 ||
+            !sensitiveKey(key) ||
+            placeholder(candidate) ||
+            ((normalizedKey(key) === "authorization" ||
+                normalizedKey(key) === "proxy_authorization") &&
+                /^(?:Bearer|Basic)$/i.test(candidate)))
+            continue;
+        const start = match.index + match[0].lastIndexOf(candidate);
+        addRange(ranges, start, start + candidate.length, value.length);
+    }
+    for (const match of value.matchAll(authorization)) {
+        const candidate = match[1];
+        if (candidate === undefined || placeholder(candidate))
+            continue;
+        const start = match.index + match[0].lastIndexOf(candidate);
+        addRange(ranges, start, start + candidate.length, value.length);
+    }
+    for (const match of value.matchAll(privateKey)) {
+        addRange(ranges, match.index, match.index + match[0].length, value.length);
+    }
+    return ranges;
+}
+function replaceRanges(value, ranges) {
+    if (ranges.length === 0)
+        return value;
+    ranges.sort((a, b) => a.start - b.start || a.end - b.end);
+    const merged = [];
+    for (const range of ranges) {
+        const previous = merged.at(-1);
+        if (previous !== undefined && range.start <= previous.end) {
+            merged[merged.length - 1] = {
+                start: previous.start,
+                end: Math.max(previous.end, range.end),
+            };
+        }
+        else
+            merged.push(range);
+    }
+    let result = value;
+    for (let index = merged.length - 1; index >= 0; index -= 1) {
+        const range = merged[index];
+        if (range === undefined)
+            continue;
+        result = `${result.slice(0, range.start)}${REDACTED}${result.slice(range.end)}`;
+    }
+    return result;
+}
+async function redactText(value) {
+    if (value.length === 0 || value === REDACTED)
+        return value;
+    const ranges = textRanges(value);
+    let result;
+    try {
+        result = await lintSource({
+            source: {
+                contentType: "text",
+                content: value,
+                filePath: "trace.txt",
+                ext: "txt",
+            },
+            options: {
+                maskSecrets: true,
+                noPhysicFilePath: true,
+                config: secretlintConfig,
+            },
+        });
+    }
+    catch {
+        throw new Error("Local trace secret scanning failed; the event was not queued.");
+    }
+    for (const message of result.messages) {
+        addRange(ranges, message.range[0], message.range[1], value.length);
+    }
+    return replaceRanges(value, ranges);
+}
+async function redactValue(value, cache, force) {
+    const parsedText = z.string().safeParse(value);
+    if (parsedText.success) {
+        const text = parsedText.data;
+        if (force)
+            return placeholder(text) ? text : REDACTED;
+        let result = cache.get(text);
+        if (result === undefined) {
+            result = redactText(text);
+            cache.set(text, result);
+        }
+        return result;
+    }
+    if (value === null || value === true || value === false)
+        return value;
+    const parsedNumber = z.number().safeParse(value);
+    if (parsedNumber.success)
+        return force ? REDACTED : parsedNumber.data;
+    if (Array.isArray(value)) {
+        const items = await Promise.all(value.map((item) => redactValue(item, cache, force)));
+        return items.every((item, index) => item === value[index]) ? value : items;
+    }
+    const record = value;
+    const entries = await Promise.all(Object.entries(record).map(async ([key, item]) => [
+        key,
+        await redactValue(item, cache, force || sensitiveKey(key)),
+    ]));
+    return entries.every(([key, item]) => item === record[key])
+        ? value
+        : Object.fromEntries(entries);
+}
+export async function redactTraceEvent(event) {
+    const cache = new Map();
+    if (event.payload.sourceType === "cursor_subagent_transcript") {
+        const parsed = z.string().safeParse(event.payload.base64);
+        if (!parsed.success)
+            throw new Error("Cursor transcript has invalid encoded content.");
+        const bytes = Buffer.from(parsed.data, "base64");
+        if (bytes.toString("base64") !== parsed.data)
+            throw new Error("Cursor transcript has invalid encoded content.");
+        const raw = bytes.toString("latin1");
+        const redacted = await redactText(raw);
+        const { base64: _encoded, ...remaining } = event.payload;
+        const payload = await redactValue(remaining, cache, false);
+        return {
+            ...event,
+            payload: {
+                ...payload,
+                base64: redacted === raw
+                    ? parsed.data
+                    : Buffer.from(redacted, "latin1").toString("base64"),
+            },
+        };
+    }
+    const payload = await redactValue(event.payload, cache, false);
+    return payload === event.payload
+        ? event
+        : { ...event, payload: payload };
+}

package/dist/service.js

@@ -5,7 +5,8 @@ import { connectNewDetectedSources, loadMachineConsent, } from "./auto-connect.j
 import { collectorFetch } from "./collector-fetch.js";
 import { collectorTick, TraceUploadError } from "./collector.js";
 import { refreshTurnSummaries } from "./turn-summary.js";
-import { collectorSource, collectorPaths, ensureClaudeHistoryBackfill, ensureHistoryBackfill, ensurePrivateDirectory, healthSnapshot, loadConfig, saveHealth, } from "./storage.js";
+import { installCursorHooks } from "./cursor-hooks.js";
+import { collectorSource, collectorPaths, ensureClaudeHistoryBackfill, ensureCursorHistoryBackfill, ensureHistoryBackfill, ensurePrivateDirectory, healthSnapshot, loadConfig, saveHealth, } from "./storage.js";
 function errorCode(error) {
     if (error instanceof Error && "code" in error)
         return String(error.code);
@@ -125,7 +126,11 @@ export async function runCollector(directory, expectedSource) {
                 message: "Local collector status could not be read; collection continues.",
             }));
         }
-        if ("claudeHome" in config)
+        if ("cursorHome" in config) {
+            await ensureCursorHistoryBackfill(config.cursorHome, paths);
+            await installCursorHooks(config.cursorHome, config.dataDirectory);
+        }
+        else if ("claudeHome" in config)
             await ensureClaudeHistoryBackfill(config.claudeHome, paths);
         else
             await ensureHistoryBackfill(config.codexHome, paths);
@@ -208,7 +213,8 @@ export async function runCollector(directory, expectedSource) {
                 retryDelayMs = Math.min(retryDelayMs * 2, 60_000);
             }
             try {
-                await refreshTurnSummaries(config, summariesRefreshedAt, Date.now(), collectorFetch, controller.signal);
+                if (source !== "cursor")
+                    await refreshTurnSummaries(config, summariesRefreshedAt, Date.now(), collectorFetch, controller.signal);
             }
             catch (error) {
                 if (controller.signal.aborted)