iteration-cli 0.9.1 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iteration-cli",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "type": "module",
   "repository": {
     "type": "git",
@@ -16,14 +16,15 @@
   "bin": {
     "iteration": "./dist/cli.js"
   },
-  "dependencies": {
+  "devDependencies": {
     "@secretlint/core": "13.0.6",
     "@secretlint/profiler": "13.0.6",
     "@secretlint/secretlint-rule-preset-recommend": "13.0.6",
+    "esbuild": "0.28.2",
     "zod": "4.6.4",
     "iteration-trace-contracts": "0.7.0"
   },
   "scripts": {
-    "build": "pnpm --filter iteration-trace-contracts build && tsc -p tsconfig.json"
+    "build": "pnpm --filter iteration-trace-contracts build && tsc -p tsconfig.json --noEmit && node build.mjs"
   }
 }

package/dist/auto-connect.d.ts

@@ -1,32 +0,0 @@
-import { type CollectorSource } from "iteration-trace-contracts";
-import { type CollectorFetcher } from "./collector-fetch.js";
-import { type CollectorConfig, type CollectorState } from "./storage.js";
-export type MachineConsent = Readonly<{
-    version: 1;
-    endpoint: string;
-    organizationId: string;
-    anchorSource: CollectorSource;
-    anchorDataDirectory: string;
-    sourceHomes: Readonly<{
-        codex: string;
-        claude: string;
-        cursor: string;
-    }>;
-}>;
-export declare function sourceHome(source: CollectorSource): string;
-export declare function detectedSources(sourceHomes: MachineConsent["sourceHomes"]): Promise<CollectorSource[]>;
-export declare function loadMachineConsent(): Promise<MachineConsent | null>;
-export declare function saveMachineConsent(consent: MachineConsent): Promise<void>;
-export type SourceEnrollment = Readonly<{
-    token: string;
-    organizationId: string;
-    organizationName: string;
-}>;
-export declare function readCollectorScope(anchor: CollectorConfig): Promise<Readonly<{
-    organizationId: string;
-    organizationName: string;
-}>>;
-export declare function expandSource(anchor: CollectorConfig, source: CollectorSource, organizationId: string | null, request?: CollectorFetcher): Promise<SourceEnrollment>;
-export declare function activateSource(source: CollectorSource, home: string, endpoint: string, enrollment: SourceEnrollment, state: CollectorState): Promise<CollectorConfig>;
-export declare function connectNewDetectedSources(anchor: CollectorConfig, consent: MachineConsent): Promise<CollectorSource[]>;
-export declare function connectedConfig(source: CollectorSource): Promise<CollectorConfig | null>;

package/dist/auto-connect.js

@@ -1,235 +0,0 @@
-import { promises as fs } from "node:fs";
-import { createHmac } from "node:crypto";
-import os from "node:os";
-import path from "node:path";
-import * as z from "zod";
-import { COLLECTOR_SOURCES, parseCollectorEnrollmentResponse, } from "iteration-trace-contracts";
-import { installBackgroundService } from "./background-service.js";
-import { collectorFetch } from "./collector-fetch.js";
-import { installTurnSummary } from "./turn-summary.js";
-import { installCursorHooks } from "./cursor-hooks.js";
-import { assertFreshCollectorDirectory, collectorPaths, defaultCollectorDirectory, ensurePrivateDirectory, loadConfig, prepareSourceInitialState, saveConfig, saveState, validateCollectorEndpoint, } from "./storage.js";
-const consentSchema = z
-    .object({
-    version: z.literal(1),
-    endpoint: z.url(),
-    organizationId: z.uuid(),
-    anchorSource: z.enum(COLLECTOR_SOURCES),
-    anchorDataDirectory: z.string(),
-    sourceHomes: z
-        .object({
-        codex: z.string(),
-        claude: z.string(),
-        cursor: z.string().default(path.join(os.homedir(), ".cursor")),
-    })
-        .strict(),
-})
-    .strict();
-function consentPath() {
-    return path.join(os.homedir(), ".config", "iteration", "auto-connect.json");
-}
-export function sourceHome(source) {
-    return path.resolve(source === "codex"
-        ? (process.env.CODEX_HOME ?? path.join(os.homedir(), ".codex"))
-        : source === "claude"
-            ? (process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude"))
-            : path.join(os.homedir(), ".cursor"));
-}
-export async function detectedSources(sourceHomes) {
-    const detected = [];
-    for (const source of COLLECTOR_SOURCES) {
-        const directory = path.join(sourceHomes[source], source === "codex" ? "sessions" : "projects");
-        let stats;
-        try {
-            stats = await fs.stat(directory);
-        }
-        catch (error) {
-            if (error instanceof Error && "code" in error && error.code === "ENOENT")
-                continue;
-            throw new Error(`Could not inspect ${source} sessions at ${directory}.`, {
-                cause: error,
-            });
-        }
-        if (!stats.isDirectory()) {
-            throw new Error(`${source} session path is not a directory: ${directory}.`);
-        }
-        detected.push(source);
-    }
-    return detected;
-}
-export async function loadMachineConsent() {
-    let text;
-    try {
-        text = await fs.readFile(consentPath(), "utf8");
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return null;
-        throw new Error("Could not read automatic source connection settings.", {
-            cause: error,
-        });
-    }
-    let decoded;
-    try {
-        decoded = JSON.parse(text);
-    }
-    catch (error) {
-        throw new Error("Automatic source connection settings are invalid.", {
-            cause: error,
-        });
-    }
-    const parsed = consentSchema.safeParse(decoded);
-    if (!parsed.success)
-        throw new Error("Automatic source connection settings are invalid.");
-    validateCollectorEndpoint(parsed.data.endpoint);
-    return parsed.data;
-}
-export async function saveMachineConsent(consent) {
-    const parsed = consentSchema.parse(consent);
-    validateCollectorEndpoint(parsed.endpoint);
-    const filename = consentPath();
-    await ensurePrivateDirectory(path.dirname(filename));
-    const temporary = `${filename}.${process.pid}.tmp`;
-    const handle = await fs.open(temporary, "w", 0o600);
-    try {
-        await handle.writeFile(`${JSON.stringify(parsed)}\n`, "utf8");
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-    await fs.rename(temporary, filename);
-}
-export async function readCollectorScope(anchor) {
-    const endpoint = validateCollectorEndpoint(anchor.endpoint);
-    const response = await collectorFetch(new URL("./collector-auth/expand", endpoint), {
-        headers: { Authorization: `Bearer ${anchor.token}` },
-        signal: AbortSignal.timeout(10_000),
-    });
-    const payload = await response.json();
-    if (!response.ok) {
-        const error = z.object({ error: z.string() }).safeParse(payload);
-        throw new Error(`Could not identify the collector workspace: ${error.success ? error.data.error : `HTTP ${response.status}`}`);
-    }
-    const parsed = z
-        .object({ organizationId: z.uuid(), organizationName: z.string().min(1) })
-        .strict()
-        .safeParse(payload);
-    if (!parsed.success)
-        throw new Error("Iteration returned an invalid collector workspace.");
-    return parsed.data;
-}
-export async function expandSource(anchor, source, organizationId, request = collectorFetch) {
-    const endpoint = validateCollectorEndpoint(anchor.endpoint);
-    const token = createHmac("sha256", anchor.token)
-        .update(`iteration-source:${source}`, "utf8")
-        .digest("base64url");
-    const response = await request(new URL("./collector-auth/expand", endpoint), {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${anchor.token}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            source,
-            token,
-            ...(organizationId === null ? {} : { organizationId }),
-        }),
-        signal: AbortSignal.timeout(15_000),
-    });
-    const payload = await response.json();
-    if (!response.ok) {
-        const error = z.object({ error: z.string() }).safeParse(payload);
-        throw new Error(`Could not connect ${source}: ${error.success ? error.data.error : `HTTP ${response.status}`}`);
-    }
-    const parsed = parseCollectorEnrollmentResponse(payload);
-    if (!parsed.success || parsed.value.status !== "enrolled") {
-        throw new Error(`Iteration returned an invalid ${source} connection response.`);
-    }
-    if (organizationId !== null &&
-        parsed.value.organizationId !== organizationId) {
-        throw new Error(`Iteration connected ${source} to an unexpected workspace.`);
-    }
-    return parsed.value;
-}
-export async function activateSource(source, home, endpoint, enrollment, state) {
-    const directory = defaultCollectorDirectory(source);
-    const paths = collectorPaths(directory);
-    await assertFreshCollectorDirectory(paths, source);
-    const common = {
-        endpoint,
-        token: enrollment.token,
-        dataDirectory: directory,
-        organizationId: enrollment.organizationId,
-        organizationName: enrollment.organizationName,
-    };
-    const config = source === "codex"
-        ? { ...common, codexHome: home }
-        : source === "claude"
-            ? { ...common, source: "claude", claudeHome: home }
-            : { ...common, source: "cursor", cursorHome: home };
-    await saveConfig(config, paths);
-    try {
-        await saveState(state, paths);
-        if (source === "cursor")
-            await installCursorHooks(home, directory);
-        await installBackgroundService(directory, source);
-    }
-    catch (error) {
-        throw new Error(`${source} was connected, but local startup failed. Run iteration start ${source} to repair it.`, { cause: error });
-    }
-    return config;
-}
-export async function connectNewDetectedSources(anchor, consent) {
-    if (anchor.dataDirectory !== consent.anchorDataDirectory ||
-        anchor.endpoint !== consent.endpoint) {
-        throw new Error("Automatic connection settings do not match the running collector.");
-    }
-    const detected = await detectedSources(consent.sourceHomes);
-    const connected = [];
-    for (const source of detected) {
-        if (source === consent.anchorSource)
-            continue;
-        const paths = collectorPaths(defaultCollectorDirectory(source));
-        try {
-            await fs.access(paths.config);
-            continue;
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-                throw error;
-        }
-        await assertFreshCollectorDirectory(paths, source);
-        const state = await prepareSourceInitialState(source, consent.sourceHomes[source], true);
-        const enrollment = await expandSource(anchor, source, consent.organizationId);
-        const config = await activateSource(source, consent.sourceHomes[source], consent.endpoint, enrollment, state);
-        connected.push(source);
-        try {
-            if (source !== "cursor")
-                await installTurnSummary(config);
-        }
-        catch (error) {
-            console.error(JSON.stringify({
-                level: "warning",
-                source,
-                operation: "install_turn_summary",
-                message: error instanceof Error
-                    ? error.message
-                    : "The turn summary could not be installed.",
-            }));
-        }
-    }
-    return connected;
-}
-export async function connectedConfig(source) {
-    const paths = collectorPaths(defaultCollectorDirectory(source));
-    try {
-        await fs.access(paths.config);
-    }
-    catch (error) {
-        if (error instanceof Error && "code" in error && error.code === "ENOENT")
-            return null;
-        throw error;
-    }
-    return loadConfig(paths);
-}

package/dist/background-service.d.ts

@@ -1,7 +0,0 @@
-import type { CollectorSource } from "iteration-trace-contracts";
-export declare function requireCollectorPlatform(): void;
-export declare function prepareBackgroundPersistence(): Promise<void>;
-export declare function collectorLogPath(source: CollectorSource): string;
-export declare function installBackgroundService(directory: string, source: CollectorSource): Promise<string>;
-export declare function uninstallBackgroundService(source: CollectorSource): Promise<void>;
-export declare function backgroundServiceStatus(source: CollectorSource): Promise<boolean>;

package/dist/background-service.js

@@ -1,37 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-import { installLaunchAgent, launchAgentStatus, uninstallLaunchAgent, } from "./launch-agent.js";
-import { installSystemdUserService, ensureSystemdUserLinger, systemdLogPath, systemdUserServiceStatus, uninstallSystemdUserService, } from "./systemd-user.js";
-export function requireCollectorPlatform() {
-    if (process.platform !== "darwin" && process.platform !== "linux") {
-        throw new Error("Automatic startup is supported on macOS and Linux only.");
-    }
-}
-export async function prepareBackgroundPersistence() {
-    requireCollectorPlatform();
-    if (process.platform === "linux")
-        await ensureSystemdUserLinger();
-}
-export function collectorLogPath(source) {
-    if (process.platform === "linux")
-        return systemdLogPath(source);
-    return path.join(os.homedir(), "Library", "Logs", `iteration-${source}-collector.error.log`);
-}
-export async function installBackgroundService(directory, source) {
-    requireCollectorPlatform();
-    return process.platform === "darwin"
-        ? installLaunchAgent(directory, source)
-        : installSystemdUserService(directory, source);
-}
-export async function uninstallBackgroundService(source) {
-    requireCollectorPlatform();
-    return process.platform === "darwin"
-        ? uninstallLaunchAgent(source)
-        : uninstallSystemdUserService(source);
-}
-export async function backgroundServiceStatus(source) {
-    requireCollectorPlatform();
-    return process.platform === "darwin"
-        ? launchAgentStatus(source)
-        : systemdUserServiceStatus(source);
-}

package/dist/claude-transcript.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,256 +0,0 @@
-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",
-    "pr-link",
-]);
-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,7 +0,0 @@
-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;
-    organizationId: string;
-    organizationName: string;
-}>>;