iteration-cli 0.9.1 → 0.10.0

package/dist/clerk-device-auth.js

@@ -1,279 +0,0 @@
-import { execFile } from "node:child_process";
-import { createInterface } from "node:readline/promises";
-import { promisify } from "node:util";
-import { parseCollectorEnrollmentResponse, } from "iteration-trace-contracts";
-import * as z from "zod";
-const execFileAsync = promisify(execFile);
-const serverAuthConfigSchema = z
-    .object({
-    issuerUrl: z.url(),
-    clientId: z.string().min(1),
-})
-    .strict();
-const oauthMetadataSchema = z.object({
-    device_authorization_endpoint: z.url(),
-    token_endpoint: z.url(),
-    issuer: z.url().optional(),
-});
-const deviceCodeSchema = z.object({
-    device_code: z.string().min(1),
-    user_code: z.string().min(1),
-    verification_uri: z.url(),
-    verification_uri_complete: z.url().optional(),
-    expires_in: z.number().int().min(1).max(86_400),
-    interval: z.number().int().min(1).max(3_600),
-});
-const oauthTokenSchema = z.object({
-    access_token: z.string().min(1),
-});
-const oauthErrorSchema = z.object({
-    error: z.string().min(1),
-    error_description: z.string().optional(),
-});
-function apiRoute(endpoint, relativePath) {
-    return new URL(relativePath, endpoint);
-}
-async function responseJson(response) {
-    try {
-        return await response.json();
-    }
-    catch (error) {
-        throw new Error("The authentication server returned invalid JSON.", {
-            cause: error,
-        });
-    }
-}
-async function loadOAuthConfiguration(endpoint) {
-    const response = await fetch(apiRoute(endpoint, "./collector-auth/config"), {
-        signal: AbortSignal.timeout(10_000),
-    });
-    const body = await responseJson(response);
-    if (!response.ok) {
-        throw new Error(response.status === 503
-            ? "Collector sign-in is not configured on the Iteration server."
-            : "Could not load collector sign-in configuration.");
-    }
-    const parsed = serverAuthConfigSchema.safeParse(body);
-    if (!parsed.success) {
-        throw new Error("Collector sign-in configuration has an invalid shape.");
-    }
-    const issuer = new URL(parsed.data.issuerUrl);
-    if (issuer.protocol !== "https:" ||
-        issuer.username !== "" ||
-        issuer.password !== "" ||
-        issuer.pathname !== "/" ||
-        issuer.search !== "" ||
-        issuer.hash !== "") {
-        throw new Error("The configured Clerk issuer URL is invalid.");
-    }
-    return { issuerUrl: issuer.origin, clientId: parsed.data.clientId };
-}
-async function discoverDeviceEndpoints(issuerUrl) {
-    const issuer = new URL(issuerUrl);
-    const response = await fetch(new URL(".well-known/oauth-authorization-server", issuer), { signal: AbortSignal.timeout(10_000) });
-    if (!response.ok) {
-        throw new Error("Clerk OAuth device authorization is unavailable.");
-    }
-    const parsed = oauthMetadataSchema.safeParse(await responseJson(response));
-    if (!parsed.success) {
-        throw new Error("Clerk OAuth metadata does not advertise device authorization.");
-    }
-    const deviceAuthorizationUrl = new URL(parsed.data.device_authorization_endpoint);
-    const tokenUrl = new URL(parsed.data.token_endpoint);
-    if (deviceAuthorizationUrl.protocol !== "https:" ||
-        tokenUrl.protocol !== "https:" ||
-        deviceAuthorizationUrl.origin !== issuer.origin ||
-        tokenUrl.origin !== issuer.origin) {
-        throw new Error("Clerk OAuth metadata contains an unexpected endpoint.");
-    }
-    return {
-        deviceAuthorizationUrl,
-        tokenUrl,
-    };
-}
-async function openBrowser(url) {
-    try {
-        await execFileAsync("open", [url], { timeout: 5000 });
-    }
-    catch {
-        process.stdout.write("Open the verification link in your browser.\n");
-    }
-}
-function delay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-async function requestDeviceCode(url, clientId) {
-    const body = new URLSearchParams({
-        client_id: clientId,
-        scope: "openid profile email",
-    });
-    const response = await fetch(url, {
-        method: "POST",
-        headers: { "Content-Type": "application/x-www-form-urlencoded" },
-        body,
-        signal: AbortSignal.timeout(10_000),
-    });
-    const payload = await responseJson(response);
-    const parsed = deviceCodeSchema.safeParse(payload);
-    if (!response.ok || !parsed.success) {
-        const providerError = oauthErrorSchema.safeParse(payload);
-        throw new Error(providerError.success
-            ? "Clerk device sign-in could not start: " +
-                (providerError.data.error_description ?? providerError.data.error)
-            : "Clerk returned an invalid device authorization response.");
-    }
-    return parsed.data;
-}
-async function pollForAccessToken(tokenUrl, clientId, deviceCode, expiresIn, initialInterval) {
-    const expiresAt = Date.now() + expiresIn * 1000;
-    let interval = initialInterval;
-    while (Date.now() < expiresAt) {
-        await delay(interval * 1000);
-        if (Date.now() >= expiresAt)
-            break;
-        let response;
-        try {
-            response = await fetch(tokenUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/x-www-form-urlencoded" },
-                body: new URLSearchParams({
-                    client_id: clientId,
-                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-                    device_code: deviceCode,
-                }),
-                signal: AbortSignal.timeout(10_000),
-            });
-        }
-        catch {
-            continue;
-        }
-        const payload = await responseJson(response);
-        const token = oauthTokenSchema.safeParse(payload);
-        if (response.ok && token.success)
-            return token.data.access_token;
-        const providerError = oauthErrorSchema.safeParse(payload);
-        if (!providerError.success) {
-            throw new Error("Clerk returned an invalid device token response.");
-        }
-        switch (providerError.data.error) {
-            case "authorization_pending":
-                continue;
-            case "slow_down":
-                interval += 5;
-                continue;
-            case "access_denied":
-                throw new Error("You denied Iteration collector access.");
-            case "expired_token":
-                throw new Error("The sign-in code expired. Run iteration again.");
-            default:
-                throw new Error("Clerk device sign-in failed: " +
-                    (providerError.data.error_description ?? providerError.data.error));
-        }
-    }
-    throw new Error("The sign-in code expired. Run iteration again.");
-}
-async function clerkDeviceSignIn(configuration) {
-    const endpoints = await discoverDeviceEndpoints(configuration.issuerUrl);
-    const challenge = await requestDeviceCode(endpoints.deviceAuthorizationUrl, configuration.clientId);
-    const verificationUrl = challenge.verification_uri_complete ?? challenge.verification_uri;
-    process.stdout.write("Sign in to Iteration to authorize this collector.\n" +
-        "Code: " +
-        challenge.user_code +
-        "\n" +
-        "Link: " +
-        verificationUrl +
-        "\n");
-    await openBrowser(verificationUrl);
-    return pollForAccessToken(endpoints.tokenUrl, configuration.clientId, challenge.device_code, challenge.expires_in, challenge.interval);
-}
-async function enrollDevice(endpoint, accessToken, deviceName, organizationId, source) {
-    const body = { deviceName };
-    if (source !== "codex")
-        body.source = source;
-    if (organizationId !== null)
-        body.organizationId = organizationId;
-    const response = await fetch(apiRoute(endpoint, "./collector-auth/enroll"), {
-        method: "POST",
-        headers: {
-            Authorization: "Bearer " + accessToken,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(15_000),
-    });
-    const payload = await responseJson(response);
-    const parsed = parseCollectorEnrollmentResponse(payload);
-    if (response.ok && parsed.success)
-        return parsed.value;
-    const error = z.object({ error: z.string().min(1) }).safeParse(payload);
-    if (error.success) {
-        throw new Error(error.data.error);
-    }
-    throw new Error("The Iteration server returned an invalid enrollment response.");
-}
-async function chooseOrganization(organizations, hasMore) {
-    process.stdout.write("Choose an Iteration workspace for this collector:\n");
-    for (const [index, organization] of organizations.entries()) {
-        process.stdout.write(index + 1 + ". " + organization.name + " (" + organization.id + ")\n");
-    }
-    if (hasMore) {
-        process.stdout.write("More workspaces exist; enter an organization ID to choose one not listed.\n");
-    }
-    if (process.stdin.isTTY !== true) {
-        throw new Error("Run iteration interactively or pass --organization-id.");
-    }
-    const prompt = createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    try {
-        const answer = await prompt.question("Workspace number or organization ID: ");
-        const id = z.uuid().safeParse(answer.trim());
-        if (id.success)
-            return id.data;
-        const selection = z.coerce
-            .number()
-            .int()
-            .min(1)
-            .max(organizations.length)
-            .safeParse(answer.trim());
-        if (!selection.success) {
-            throw new Error("Choose a listed number or enter a valid organization ID.");
-        }
-        const organization = organizations[selection.data - 1];
-        if (organization === undefined) {
-            throw new Error("The selected workspace is not available.");
-        }
-        return organization.id;
-    }
-    finally {
-        prompt.close();
-    }
-}
-export async function authenticateAndEnrollCollector(endpoint, deviceNameValue, organizationId, source = "codex") {
-    const deviceName = z
-        .string()
-        .trim()
-        .min(1)
-        .max(160)
-        .safeParse(deviceNameValue);
-    if (!deviceName.success) {
-        throw new Error("--device-name must contain 1 to 160 characters.");
-    }
-    const configuration = await loadOAuthConfiguration(endpoint);
-    const clerkAccessToken = await clerkDeviceSignIn(configuration);
-    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, source);
-    }
-    if (result.status !== "enrolled") {
-        throw new Error("The collector could not be assigned to that workspace.");
-    }
-    return {
-        token: result.token,
-        deviceId: result.deviceId,
-        organizationId: result.organizationId,
-        organizationName: result.organizationName,
-    };
-}

package/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/collector-fetch.d.ts

@@ -1,9 +0,0 @@
-type CollectorRequest = Readonly<{
-    method?: "GET" | "POST";
-    headers?: Readonly<Record<string, string>>;
-    body?: string;
-    signal?: AbortSignal;
-}>;
-export type CollectorFetcher = (url: string | URL, init?: CollectorRequest) => Promise<Response>;
-export declare const collectorFetch: CollectorFetcher;
-export {};

package/dist/collector-fetch.js

@@ -1,57 +0,0 @@
-import http from "node:http";
-import https from "node:https";
-const MAX_RESPONSE_BYTES = 1024 * 1024;
-const NULL_BODY_STATUSES = new Set([101, 103, 204, 205, 304]);
-// Reused connections failed uploads in production: Node's HTTP/2 fetch kept a
-// destroyed session, and kept-alive sockets timed out on ~40 s server waits.
-// See docs/architecture/trace-ingestion.md.
-const agents = {
-    "http:": new http.Agent({ keepAlive: false }),
-    "https:": new https.Agent({ keepAlive: false }),
-};
-export const collectorFetch = (input, init = {}) => {
-    const url = new URL(input);
-    if (url.protocol !== "https:" && url.protocol !== "http:") {
-        throw new TypeError(`Unsupported collector request protocol ${url.protocol}`);
-    }
-    const body = init.body ?? null;
-    const headers = { ...init.headers };
-    if (body !== null) {
-        headers["content-length"] = String(Buffer.byteLength(body, "utf8"));
-    }
-    const transport = url.protocol === "https:" ? https : http;
-    return new Promise((resolve, reject) => {
-        const request = transport.request(url, {
-            method: init.method ?? "GET",
-            headers,
-            agent: agents[url.protocol],
-            signal: init.signal,
-        }, (response) => {
-            const chunks = [];
-            let size = 0;
-            response.on("data", (chunk) => {
-                size += chunk.byteLength;
-                if (size > MAX_RESPONSE_BYTES) {
-                    response.destroy(new Error("Iteration returned an oversized response."));
-                    return;
-                }
-                chunks.push(chunk);
-            });
-            response.on("error", reject);
-            response.on("end", () => {
-                const status = response.statusCode ?? 0;
-                const responseHeaders = new Headers();
-                for (const [name, value] of Object.entries(response.headers)) {
-                    if (value === undefined)
-                        continue;
-                    for (const item of Array.isArray(value) ? value : [value]) {
-                        responseHeaders.append(name, item);
-                    }
-                }
-                resolve(new Response(NULL_BODY_STATUSES.has(status) ? null : Buffer.concat(chunks), { status, headers: responseHeaders }));
-            });
-        });
-        request.on("error", reject);
-        request.end(body ?? undefined);
-    });
-};

package/dist/collector.d.ts

@@ -1,17 +0,0 @@
-import { type CollectorFetcher } from "./collector-fetch.js";
-import { type CollectorConfig, type CollectorPaths } from "./storage.js";
-export declare class TraceUploadError extends Error {
-    readonly kind: "http" | "network" | "response";
-    readonly status: number | null;
-    constructor(kind: "http" | "network" | "response", status: number | null, message: string, options?: ErrorOptions);
-}
-export declare function scanSourceOnce(config: CollectorConfig, paths: CollectorPaths, signal?: AbortSignal): Promise<Readonly<{
-    discovered: number;
-    caughtUp: boolean;
-}>>;
-export declare function collectorTick(config: CollectorConfig, paths: CollectorPaths, fetcher?: CollectorFetcher, signal?: AbortSignal, onAcknowledged?: () => void): Promise<Readonly<{
-    discovered: number;
-    uploaded: number;
-    outboxBytes: number;
-    historyCaughtUp: boolean;
-}>>;

package/dist/collector.js

@@ -1,268 +0,0 @@
-import { promises as fs } from "node:fs";
-import path from "node:path";
-import { parseTraceEventAcknowledgement, } from "iteration-trace-contracts";
-import { collectorFetch } from "./collector-fetch.js";
-import { parseClaudeLine } from "./claude-transcript.js";
-import { cursorHookFiles } from "./cursor-hooks.js";
-import { parseCursorHookLine, parseCursorTranscriptLine, } from "./cursor-transcript.js";
-import { redactTraceEvent } from "./redact-trace.js";
-import { parseRolloutLine } from "./rollout.js";
-import { acknowledgeEvents, appendEvents, collectorSource, collectorSourceDirectory, loadState, nextBatch, outboxSize, pendingEventIds, redactPendingOutbox, sourceFiles, saveState, } from "./storage.js";
-const MAX_SCAN_BYTES_PER_FILE = 16 * 1024 * 1024;
-const MAX_SCAN_BYTES_PER_TICK = 16 * 1024 * 1024;
-const MAX_RECORD_BYTES = 3 * 1024 * 1024;
-const MAX_UPLOAD_BYTES = 3 * 1024 * 1024;
-const MAX_EVENT_BYTES = MAX_UPLOAD_BYTES - 1024;
-const MAX_UPLOADS_PER_TICK = 5;
-const MAX_REQUEST_BYTES = 4 * 1024 * 1024;
-// Production stores some batches in about 40 seconds. Abandoning a request
-// earlier does not stop the server, so the retry only waits behind it and the
-// collector reports a failure for work that succeeded.
-const UPLOAD_TIMEOUT_MS = 90_000;
-// A tick can queue up to MAX_SCAN_BYTES_PER_TICK of new events, so scanning
-// pauses well below the outbox capacity and resumes once uploads drain it.
-const SCAN_PAUSE_OUTBOX_BYTES = 32 * 1024 * 1024;
-const UTF8_DECODER = new TextDecoder("utf-8", { fatal: true });
-export class TraceUploadError extends Error {
-    kind;
-    status;
-    constructor(kind, status, message, options) {
-        super(message, options);
-        this.name = "TraceUploadError";
-        this.kind = kind;
-        this.status = status;
-    }
-}
-function logGap(filename, offset, reason) {
-    console.error(JSON.stringify({
-        level: "capture_gap",
-        filename,
-        offset,
-        reason,
-    }));
-}
-function parseSourceRecord(source, line, filename, byteOffset) {
-    if (source === "claude")
-        return parseClaudeLine(line, filename, byteOffset);
-    if (source === "cursor")
-        return filename.includes(`${path.sep}cursor-hooks${path.sep}`)
-            ? parseCursorHookLine(line, filename)
-            : parseCursorTranscriptLine(line, filename, byteOffset);
-    if (source === "codex") {
-        const parsed = parseRolloutLine(line, filename, byteOffset);
-        return parsed.kind === "event"
-            ? { events: [parsed.event], gaps: [] }
-            : parsed.kind === "gap"
-                ? { events: [], gaps: [parsed.reason] }
-                : { events: [], gaps: [] };
-    }
-    const unhandled = source;
-    throw new Error(`Unsupported collector source: ${unhandled}`);
-}
-export async function scanSourceOnce(config, paths, signal) {
-    signal?.throwIfAborted();
-    const source = collectorSource(config);
-    const sourceDirectory = path.resolve(collectorSourceDirectory(config));
-    const state = await loadState(paths);
-    if (!state.initialized || state.sourceDirectory !== sourceDirectory) {
-        throw new Error(`Collector state does not match the ${source} directory; run iteration connect ${source} again.`);
-    }
-    const cursors = { ...state.cursors };
-    const skipping = new Set(state.skipping);
-    const files = [
-        ...(await sourceFiles(source, sourceDirectory)),
-        ...(source === "cursor" ? await cursorHookFiles(config.dataDirectory) : []),
-    ];
-    const completedHooks = [];
-    const queuedIds = await pendingEventIds(paths);
-    const tickIndexes = new Map();
-    const events = [];
-    let remainingBudget = MAX_SCAN_BYTES_PER_TICK;
-    let caughtUp = true;
-    for (const filename of files) {
-        signal?.throwIfAborted();
-        const recordLimit = source === "cursor" &&
-            filename.includes(`${path.sep}cursor-hooks${path.sep}`)
-            ? 12 * 1024 * 1024
-            : MAX_RECORD_BYTES;
-        if (remainingBudget === 0) {
-            caughtUp = false;
-            break;
-        }
-        const stats = await fs.stat(filename);
-        let offset = cursors[filename] ?? 0;
-        if (offset > stats.size) {
-            logGap(filename, offset, "rollout_file_shrank_resetting_cursor");
-            offset = 0;
-            skipping.delete(filename);
-        }
-        const bytesToRead = Math.min(stats.size - offset, MAX_SCAN_BYTES_PER_FILE, remainingBudget);
-        if (bytesToRead === 0) {
-            cursors[filename] = offset;
-            continue;
-        }
-        const handle = await fs.open(filename, "r");
-        let buffer;
-        let readEnd = offset;
-        try {
-            buffer = Buffer.alloc(bytesToRead);
-            const result = await handle.read(buffer, 0, bytesToRead, offset);
-            buffer = buffer.subarray(0, result.bytesRead);
-            readEnd = offset + result.bytesRead;
-            remainingBudget -= result.bytesRead;
-        }
-        finally {
-            await handle.close();
-        }
-        if (readEnd < stats.size)
-            caughtUp = false;
-        if (skipping.has(filename)) {
-            const newline = buffer.indexOf(10);
-            if (newline < 0) {
-                cursors[filename] = offset + buffer.length;
-                continue;
-            }
-            offset += newline + 1;
-            buffer = buffer.subarray(newline + 1);
-            skipping.delete(filename);
-        }
-        let lineStart = 0;
-        for (let index = 0; index < buffer.length; index += 1) {
-            if (buffer[index] !== 10)
-                continue;
-            let lineBytes = buffer.subarray(lineStart, index);
-            if (lineBytes.at(-1) === 13)
-                lineBytes = lineBytes.subarray(0, -1);
-            const byteOffset = offset + lineStart;
-            if (lineBytes.length > recordLimit) {
-                logGap(filename, byteOffset, "rollout_record_exceeds_scan_limit");
-                lineStart = index + 1;
-                continue;
-            }
-            let line;
-            try {
-                line = UTF8_DECODER.decode(lineBytes);
-            }
-            catch {
-                logGap(filename, byteOffset, "rollout_record_is_not_utf8");
-                lineStart = index + 1;
-                continue;
-            }
-            const parsed = parseSourceRecord(source, line, filename, byteOffset);
-            for (const reason of parsed.gaps)
-                logGap(filename, byteOffset, reason);
-            for (const parsedEvent of parsed.events) {
-                // Claude repeats a response's usage on every line of that response,
-                // and only the last copy carries the final output count.
-                const queuedAt = tickIndexes.get(parsedEvent.eventId);
-                if (queuedAt !== undefined &&
-                    parsedEvent.eventType === "token_usage_record") {
-                    const event = await redactTraceEvent(parsedEvent);
-                    if (Buffer.byteLength(JSON.stringify(event), "utf8") <= MAX_EVENT_BYTES)
-                        events[queuedAt] = event;
-                    continue;
-                }
-                if (queuedIds.has(parsedEvent.eventId))
-                    continue;
-                const event = await redactTraceEvent(parsedEvent);
-                const eventBytes = Buffer.byteLength(JSON.stringify(event), "utf8");
-                if (eventBytes > MAX_EVENT_BYTES) {
-                    logGap(filename, byteOffset, "normalized_event_exceeds_upload_limit");
-                }
-                else {
-                    tickIndexes.set(event.eventId, events.length);
-                    events.push(event);
-                    queuedIds.add(event.eventId);
-                }
-            }
-            lineStart = index + 1;
-        }
-        if (buffer.length - lineStart > recordLimit) {
-            logGap(filename, offset + lineStart, "incomplete_rollout_record_exceeds_scan_limit");
-            skipping.add(filename);
-            lineStart = buffer.length;
-        }
-        cursors[filename] = offset + lineStart;
-        if (source === "cursor" &&
-            filename.includes(`${path.sep}cursor-hooks${path.sep}`) &&
-            cursors[filename] === stats.size)
-            completedHooks.push(filename);
-    }
-    await appendEvents(events, paths);
-    for (const filename of completedHooks) {
-        await fs.rm(filename);
-        delete cursors[filename];
-    }
-    await saveState({
-        cursors,
-        skipping: [...skipping],
-        sourceDirectory: state.sourceDirectory,
-        initialized: true,
-    }, paths);
-    return { discovered: events.length, caughtUp };
-}
-async function uploadPendingOnce(config, paths, fetcher = collectorFetch, signal, onAcknowledged) {
-    let uploaded = 0;
-    for (let attempt = 0; attempt < MAX_UPLOADS_PER_TICK; attempt += 1) {
-        signal?.throwIfAborted();
-        const batch = await nextBatch(paths, MAX_UPLOAD_BYTES);
-        if (batch.length === 0)
-            return uploaded;
-        const body = JSON.stringify({ events: batch });
-        if (Buffer.byteLength(body, "utf8") > MAX_REQUEST_BYTES) {
-            throw new Error("Queued trace batch exceeds the upload request limit.");
-        }
-        let response;
-        try {
-            response = await fetcher(config.endpoint, {
-                method: "POST",
-                headers: {
-                    authorization: `Bearer ${config.token}`,
-                    "content-type": "application/json",
-                },
-                body,
-                signal: signal
-                    ? AbortSignal.any([signal, AbortSignal.timeout(UPLOAD_TIMEOUT_MS)])
-                    : AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
-            });
-        }
-        catch (error) {
-            if (signal?.aborted)
-                throw error;
-            throw new TraceUploadError("network", null, "Trace upload could not reach Iteration.", { cause: error });
-        }
-        if (response.status !== 202) {
-            throw new TraceUploadError("http", response.status, `Trace upload failed with HTTP ${response.status}.`);
-        }
-        let acknowledgement;
-        try {
-            acknowledgement = await response.json();
-        }
-        catch (error) {
-            throw new TraceUploadError("response", null, "Trace upload returned an unreadable acknowledgement.", { cause: error });
-        }
-        const expectedIds = batch.map((event) => event.eventId);
-        const parsed = parseTraceEventAcknowledgement(acknowledgement, expectedIds);
-        if (!parsed.success) {
-            throw new TraceUploadError("response", null, parsed.error);
-        }
-        await acknowledgeEvents(new Set(parsed.value.acceptedEventIds), paths);
-        onAcknowledged?.();
-        uploaded += batch.length;
-    }
-    return uploaded;
-}
-export async function collectorTick(config, paths, fetcher = collectorFetch, signal, onAcknowledged) {
-    await redactPendingOutbox(paths);
-    let uploaded = await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
-    const scan = (await outboxSize(paths)) >= SCAN_PAUSE_OUTBOX_BYTES
-        ? { discovered: 0, caughtUp: false }
-        : await scanSourceOnce(config, paths, signal);
-    uploaded += await uploadPendingOnce(config, paths, fetcher, signal, onAcknowledged);
-    return {
-        discovered: scan.discovered,
-        uploaded,
-        outboxBytes: await outboxSize(paths),
-        historyCaughtUp: scan.caughtUp,
-    };
-}

package/dist/cursor-hook-entry.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/cursor-hooks.d.ts

@@ -1,7 +0,0 @@
-export declare const CURSOR_HOOKS: readonly ["sessionStart", "beforeSubmitPrompt", "preToolUse", "postToolUse", "postToolUseFailure", "afterAgentThought", "afterAgentResponse", "preCompact", "stop", "subagentStart", "subagentStop", "sessionEnd"];
-export declare function cursorHookDirectory(dataDirectory: string): string;
-export declare function cursorHookFailurePath(dataDirectory: string): string;
-export declare function cursorHookFailureAtMs(dataDirectory: string): Promise<number | null>;
-export declare function installCursorHooks(cursorHome: string, dataDirectory: string): Promise<void>;
-export declare function uninstallCursorHooks(cursorHome: string, dataDirectory: string): Promise<void>;
-export declare function cursorHookFiles(dataDirectory: string): Promise<string[]>;