@raindrop-ai/cursor 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,613 @@
+import { z } from 'zod';
+
+declare const signalSchema: z.ZodObject<{
+    description: z.ZodString;
+    sentiment: z.ZodOptional<z.ZodEnum<{
+        POSITIVE: "POSITIVE";
+        NEGATIVE: "NEGATIVE";
+    }>>;
+}, z.core.$strip>;
+declare const diagnosticsSchema: z.ZodObject<{
+    signals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        description: z.ZodString;
+        sentiment: z.ZodOptional<z.ZodEnum<{
+            POSITIVE: "POSITIVE";
+            NEGATIVE: "NEGATIVE";
+        }>>;
+    }, z.core.$strip>>>;
+    guidance: z.ZodOptional<z.ZodString>;
+    toolName: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const configFileSchema: z.ZodObject<{
+    write_key: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    api_url: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    project_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    user_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    debug: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    enabled: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    event_name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    custom_properties: z.ZodCatch<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    self_diagnostics: z.ZodCatch<z.ZodOptional<z.ZodObject<{
+        signals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            sentiment: z.ZodOptional<z.ZodEnum<{
+                POSITIVE: "POSITIVE";
+                NEGATIVE: "NEGATIVE";
+            }>>;
+        }, z.core.$strip>>>;
+        guidance: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+declare const mapperConfigSchema: z.ZodObject<{
+    userId: z.ZodString;
+    convoId: z.ZodOptional<z.ZodString>;
+    debug: z.ZodBoolean;
+    eventName: z.ZodString;
+    customProperties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+declare const configSchema: z.ZodObject<{
+    userId: z.ZodString;
+    convoId: z.ZodOptional<z.ZodString>;
+    debug: z.ZodBoolean;
+    eventName: z.ZodString;
+    customProperties: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    writeKey: z.ZodString;
+    endpoint: z.ZodString;
+    projectId: z.ZodOptional<z.ZodString>;
+    enabled: z.ZodBoolean;
+    selfDiagnostics: z.ZodOptional<z.ZodObject<{
+        signals: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            description: z.ZodString;
+            sentiment: z.ZodOptional<z.ZodEnum<{
+                POSITIVE: "POSITIVE";
+                NEGATIVE: "NEGATIVE";
+            }>>;
+        }, z.core.$strip>>>;
+        guidance: z.ZodOptional<z.ZodString>;
+        toolName: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type SelfDiagnosticsSignalDef = z.infer<typeof signalSchema>;
+type SelfDiagnosticsConfig = z.infer<typeof diagnosticsSchema>;
+type RaindropConfig = z.infer<typeof configSchema>;
+declare function getConfigPath(): string;
+declare function loadConfig(): RaindropConfig;
+declare function updateConfig(patch: Partial<z.infer<typeof configFileSchema>>): void;
+
+type OtlpAnyValue = {
+    stringValue?: string;
+    intValue?: string;
+    doubleValue?: number;
+    boolValue?: boolean;
+    arrayValue?: {
+        values: OtlpAnyValue[];
+    };
+};
+type OtlpKeyValue = {
+    key: string;
+    value: OtlpAnyValue;
+};
+declare const SpanStatusCode: {
+    readonly UNSET: 0;
+    readonly OK: 1;
+    readonly ERROR: 2;
+};
+type OtlpSpanStatus = {
+    code: (typeof SpanStatusCode)[keyof typeof SpanStatusCode] | number;
+    message?: string;
+};
+type OtlpSpan = {
+    traceId: string;
+    spanId: string;
+    parentSpanId?: string;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano: string;
+    attributes?: OtlpKeyValue[];
+    status?: OtlpSpanStatus;
+};
+type SpanIds = {
+    traceIdB64: string;
+    spanIdB64: string;
+    parentSpanIdB64?: string;
+};
+type Attachment = {
+    type: string;
+    role: string;
+    name?: string;
+    value: string;
+};
+type IdentifyInput = {
+    userId: string;
+    traits?: Record<string, unknown>;
+};
+type EventUsage = {
+    promptTokens?: number;
+    completionTokens?: number;
+};
+type Patch = {
+    eventName?: string;
+    userId?: string;
+    convoId?: string;
+    input?: string;
+    output?: string;
+    model?: string;
+    usage?: EventUsage;
+    error?: unknown;
+    properties?: Record<string, unknown>;
+    featureFlags?: Record<string, string>;
+    attachments?: Attachment[];
+    isPending?: boolean;
+    timestamp?: string;
+};
+type SignalInput = {
+    eventId: string;
+    name: string;
+    type?: "default" | "feedback" | "edit" | "standard" | "agent" | "agent_internal";
+    sentiment?: "POSITIVE" | "NEGATIVE";
+    timestamp?: string;
+    properties?: Record<string, unknown>;
+    attachmentId?: string;
+    comment?: string;
+    after?: string;
+};
+type EventShipperOptions = {
+    writeKey?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    debug: boolean;
+    partialFlushMs?: number;
+    sdkName?: string;
+    libraryName?: string;
+    libraryVersion?: string;
+    defaultEventName?: string;
+    /**
+     * Explicit Workshop / local debugger URL. Wins over env vars + auto-detect.
+     * Pass `null` to opt out of all mirroring (including auto-detect).
+     */
+    localDebuggerUrl?: string | null;
+    /**
+     * Optional project slug. When set, every outbound cloud request includes an
+     * `X-Raindrop-Project-Id: <projectId>` header. Empty / whitespace-only
+     * values are ignored. Slug format is validated on construction but never
+     * throws — the backend returns 400 on invalid values.
+     */
+    projectId?: string;
+    /**
+     * Per-field character cap applied to event input/output BEFORE buffering
+     * or serialization, so oversized payloads cost the cap — not the payload —
+     * on the calling code path. Truncated fields end with
+     * `...[truncated by raindrop]` and never exceed the cap, marker included.
+     * Defaults to 1,000,000 (matching the Python SDK).
+     */
+    maxTextFieldChars?: number;
+};
+declare class EventShipper$1 {
+    private baseUrl;
+    private writeKey?;
+    private enabled;
+    private debug;
+    private partialFlushMs;
+    private sdkName;
+    private prefix;
+    private defaultEventName;
+    private projectId;
+    private context;
+    private buffers;
+    private sticky;
+    private timers;
+    private inFlight;
+    private maxTextFieldCharsOpt;
+    /**
+     * Epoch ms deadline while `shutdown()` is draining; undefined otherwise.
+     * Checked before every POST issued during the final flush.
+     */
+    private shutdownDeadlineAt;
+    /**
+     * Set once `shutdown()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    private hasShutdown;
+    /** URL of the local debugger / Workshop daemon, when one is reachable. */
+    private localDebuggerUrl;
+    constructor(opts: EventShipperOptions);
+    isDebugEnabled(): boolean;
+    private authHeaders;
+    private requestHeaders;
+    /**
+     * Build the retry/timeout options for one POST, honoring the shutdown
+     * deadline. Returns `null` when the shutdown drain window is exhausted —
+     * the caller must drop the payload (with a rate-limited warning) instead
+     * of issuing a request that could outlive process exit.
+     *
+     * Checked fresh on EVERY send, so a shutdown that begins while the flush
+     * path is mid-drain takes effect immediately: no further retries, and the
+     * per-attempt timeout is clamped to the remaining window. After
+     * `shutdown()` returns (deadline cleared, `hasShutdown` still set),
+     * sends — late callers, or flush work the deadline abandoned mid-drain —
+     * run as a single short attempt rather than regaining the full retry
+     * schedule.
+     */
+    private requestOpts;
+    patch(eventId: string, patch: Patch): Promise<void>;
+    finish(eventId: string, patch: Pick<Patch, "output" | "model" | "usage" | "error" | "properties" | "featureFlags" | "userId">): Promise<void>;
+    flush(): Promise<void>;
+    shutdown(): Promise<void>;
+    trackSignal(signal: SignalInput): Promise<void>;
+    identify(users: IdentifyInput | IdentifyInput[]): Promise<void>;
+    private warnShutdownDrop;
+    private flushOne;
+}
+/**
+ * Hook fired per OTLP span right before the span is shipped (to the Raindrop
+ * API and to a local debugger). Lets callers inspect, rewrite, or drop the
+ * entire span — not just individual attributes — which is more flexible than
+ * an attribute-level hook (you can rename attributes, add new ones, drop the
+ * span outright, etc.).
+ *
+ * Return values:
+ *   - `undefined` or the same span: ship the span unchanged.
+ *   - a new `OtlpSpan`: ship the returned span in place of the original.
+ *   - `null`: drop the span entirely from every ship path.
+ *
+ * The hook runs on the hot path — keep it synchronous and side-effect-free.
+ * If the hook throws, the span is dropped (fail-closed) so a buggy hook can
+ * never accidentally ship raw, un-redacted spans.
+ */
+type TransformSpanHook = (span: OtlpSpan) => OtlpSpan | null | undefined;
+
+type InternalSpan = {
+    ids: SpanIds;
+    name: string;
+    startTimeUnixNano: string;
+    endTimeUnixNano?: string;
+    attributes: Array<OtlpKeyValue | undefined>;
+};
+type TraceShipperOptions = {
+    writeKey?: string;
+    endpoint?: string;
+    enabled?: boolean;
+    debug: boolean;
+    debugSpans?: boolean;
+    flushIntervalMs?: number;
+    maxBatchSize?: number;
+    maxQueueSize?: number;
+    sdkName?: string;
+    serviceName?: string;
+    serviceVersion?: string;
+    /**
+     * Explicit Workshop / local debugger URL. Wins over env vars + auto-detect.
+     * Pass `null` to opt out of all mirroring (including auto-detect).
+     */
+    localDebuggerUrl?: string | null;
+    /**
+     * Optional project slug. When set, every OTLP trace export includes an
+     * `X-Raindrop-Project-Id: <projectId>` header. Empty / whitespace-only
+     * values are ignored. Slug format is validated on construction but never
+     * throws — the backend returns 400 on invalid values.
+     */
+    projectId?: string;
+    /**
+     * Per-span hook that fires for every OTLP span right before the span is
+     * shipped (both to the Raindrop API and to a local debugger). Lets callers
+     * inspect, rewrite, or drop entire spans — rename attributes, add new ones,
+     * scrub additional secret-shaped values inside `ai.prompt.messages` /
+     * `ai.toolCall.args`, etc.
+     *
+     * Return values:
+     *   - `undefined` or the same span reference: ship the span unchanged.
+     *   - a new `OtlpSpan`: ship the returned span in place of the original.
+     *   - `null`: drop the span entirely from every ship path.
+     *
+     * The hook runs BEFORE the default redactor (which is the always-on floor
+     * for documented BYOK secrets). The default redactor still runs on the
+     * post-transform span unless `disableDefaultRedaction` is set, so even if
+     * a custom transform overlooks a secret-shaped attribute, the floor catches
+     * it.
+     *
+     * The hook runs on the hot path — keep it synchronous and side-effect-free.
+     * If the hook itself throws, the span is dropped (fail-closed) so a buggy
+     * hook can never accidentally ship raw, un-redacted spans.
+     */
+    transformSpan?: TransformSpanHook;
+    /**
+     * Disable the built-in default span transformer (which scrubs documented
+     * secret-shaped properties — `apiKey`, `secretAccessKey`, `privateKey`,
+     * etc. — inside `ai.request.providerOptions` and
+     * `ai.response.providerMetadata`).
+     *
+     * Default: `false` (i.e. default redaction is on). Setting this to `true`
+     * disables the floor entirely; provide a custom `transformSpan` if you
+     * still want some redaction in that case.
+     */
+    disableDefaultRedaction?: boolean;
+    /**
+     * Per-attribute character cap applied to every span attribute string value
+     * right before the span enters a ship path, so a multi-MB prompt/tool
+     * payload can never make the batch `JSON.stringify` (which runs on the
+     * event loop) cost seconds. Truncated values end with
+     * `...[truncated by raindrop]` and never exceed the cap, marker included.
+     * Defaults to 1,000,000 (matching the Python SDK).
+     */
+    maxTextFieldChars?: number;
+};
+declare class TraceShipper$1 {
+    private baseUrl;
+    private writeKey?;
+    private enabled;
+    private debug;
+    private debugSpans;
+    private sdkName;
+    private prefix;
+    private serviceName;
+    private serviceVersion;
+    private flushIntervalMs;
+    private maxBatchSize;
+    private maxQueueSize;
+    private projectId;
+    private queue;
+    private timer;
+    private inFlight;
+    /** URL of the local debugger / Workshop daemon, when one is reachable. */
+    private localDebuggerUrl;
+    private transformSpanHook;
+    private disableDefaultRedaction;
+    private maxTextFieldCharsOpt;
+    /**
+     * Epoch ms deadline while `shutdown()` is draining; undefined otherwise.
+     * Checked before every batch POST issued during the final flush.
+     */
+    private shutdownDeadlineAt;
+    /**
+     * Set once `shutdown()` begins and never cleared. Sends issued after the
+     * drain window (stragglers, or flush work the deadline abandoned
+     * mid-drain) run as a single short attempt instead of regaining the full
+     * retry schedule.
+     */
+    private hasShutdown;
+    constructor(opts: TraceShipperOptions);
+    /**
+     * Cap every string attribute value on the span. O(#attributes) length
+     * checks; only oversized values pay a slice. Runs AFTER the redaction
+     * pipeline so the default secret-scrub still sees parseable JSON in
+     * `ai.request.providerOptions` / `ai.response.providerMetadata` (capping
+     * first could cut a JSON blob mid-way, fail the parse, and ship secrets
+     * in the surviving prefix).
+     *
+     * A stricter `OTEL_SPAN_ATTRIBUTE_VALUE_LENGTH_LIMIT` env var is honored
+     * for span content, matching the Python SDK and the OTel SDK convention.
+     */
+    private capSpanAttributes;
+    /**
+     * Apply the user `transformSpan` hook (if any) followed by the default
+     * redactor (unless disabled). Returns either the (possibly new) span to
+     * ship, or `null` to drop the span entirely.
+     *
+     * Ordering: user hook runs first so callers can rewrite the span freely
+     * (rename attrs, add new ones, scrub things the default doesn't know
+     * about). The default redactor then runs on whatever the user produced,
+     * acting as the always-on floor for documented BYOK secrets. If the user
+     * sets `disableDefaultRedaction: true`, the floor is skipped.
+     *
+     * Fail-closed: if the user hook throws, the span is dropped — a buggy
+     * hook can never accidentally ship raw, un-redacted spans.
+     */
+    private redactSpan;
+    isDebugEnabled(): boolean;
+    private authHeaders;
+    private requestHeaders;
+    startSpan(args: {
+        name: string;
+        parent?: {
+            traceIdB64: string;
+            spanIdB64: string;
+        };
+        eventId: string;
+        userId?: string;
+        convoId?: string;
+        eventName?: string;
+        operationId?: string;
+        attributes?: Array<OtlpKeyValue | undefined>;
+        startTimeUnixNano?: string;
+    }): InternalSpan;
+    private mirrorToLocalDebugger;
+    endSpan(span: InternalSpan, extra?: {
+        attributes?: InternalSpan["attributes"];
+        error?: unknown;
+        status?: OtlpSpanStatus;
+        endTimeUnixNano?: string;
+    }): void;
+    createSpan(args: {
+        name: string;
+        parent?: {
+            traceIdB64: string;
+            spanIdB64: string;
+        };
+        eventId: string;
+        userId?: string;
+        convoId?: string;
+        eventName?: string;
+        startTimeUnixNano: string;
+        endTimeUnixNano: string;
+        attributes?: Array<OtlpKeyValue | undefined>;
+        status?: OtlpSpanStatus;
+    }): void;
+    enqueue(span: OtlpSpan): void;
+    flush(): Promise<void>;
+    /** See EventShipper.requestOpts — same shutdown-budget semantics. */
+    private requestOpts;
+    shutdown(): Promise<void>;
+}
+
+/**
+ * Run telemetry egress with OpenTelemetry tracing suppressed.
+ *
+ * Why this exists
+ * ---------------
+ * Raindrop integrations ship spans/events over HTTP with the global `fetch`
+ * (see {@link ../http.ts `postJson`}). When the host app also runs an OTel
+ * fetch/undici instrumentation — e.g. `@vercel/otel`'s `registerOTel`, which
+ * every Eve agent installs — that instrumentation wraps *our own* telemetry
+ * POSTs in a `fetch POST <endpoint>` span. Those spans are then handed to the
+ * very exporter that issued the request, so they get shipped right back to
+ * Raindrop and Workshop as standalone "runs" (and, because each export issues
+ * another fetch, they feed back on themselves). The result is a run list
+ * flooded with `fetch POST .../v1/traces`, `.../events/track_partial` and
+ * `.../live` entries that drown out the real agent turns — especially with
+ * sub-agents, where every sandbox runs its own instrumentation.
+ *
+ * The OTel-blessed fix is to mark the active context as "tracing suppressed"
+ * around the request; instrumentations check `isTracingSuppressed` and return
+ * a no-op span instead of recording one. We do this through a hook stashed on
+ * `globalThis` by the Node entrypoint ({@link ../index.node.ts}) so that:
+ *   - `@opentelemetry/api` / `@opentelemetry/core` stay *optional* — core never
+ *     hard-depends on them, and the hook is simply absent when they (and thus
+ *     any instrumentation to suppress) are not installed; and
+ *   - the browser bundle never pulls in `node:module`, mirroring how core
+ *     injects `AsyncLocalStorage` via `RAINDROP_ASYNC_LOCAL_STORAGE`.
+ *
+ * When no hook is present the callback runs unchanged, so suppression is a
+ * best-effort no-op rather than a hard requirement.
+ */
+/** Hook signature: run `fn` with OTel tracing suppressed, returning its value. */
+type SuppressTracingHook = <T>(fn: () => T) => T;
+declare global {
+    var RAINDROP_SUPPRESS_TRACING: SuppressTracingHook | undefined;
+}
+
+type ParentSpanContext = {
+    traceIdB64: string;
+    spanIdB64: string;
+    eventId: string;
+};
+interface ContextSpan {
+    readonly traceIdB64: string;
+    readonly spanIdB64: string;
+    readonly eventId: string;
+    log?(data: Record<string, unknown>): void;
+}
+interface AsyncLocalStorageLike<T> {
+    getStore(): T | undefined;
+    run<R>(store: T, callback: () => R): R;
+    enterWith?(store: T): void;
+}
+declare abstract class ContextManager {
+    abstract getParentSpanIds(): ParentSpanContext | undefined;
+    abstract runInContext<R>(span: ContextSpan, callback: () => R): R;
+    abstract getCurrentSpan(): ContextSpan | undefined;
+    abstract isReady(): boolean;
+}
+declare global {
+    var RAINDROP_CONTEXT_MANAGER: (new () => ContextManager) | undefined;
+    var RAINDROP_ASYNC_LOCAL_STORAGE: (new <T>() => AsyncLocalStorageLike<T>) | undefined;
+}
+
+declare class EventShipper extends EventShipper$1 {
+    constructor(opts: ConstructorParameters<typeof EventShipper$1>[0]);
+}
+declare class TraceShipper extends TraceShipper$1 {
+    constructor(opts: ConstructorParameters<typeof TraceShipper$1>[0]);
+    enqueue(span: OtlpSpan): void;
+}
+
+declare const hookPayloadSchema: z.ZodObject<{
+    hook_event_name: z.ZodEnum<{
+        sessionStart: "sessionStart";
+        beforeSubmitPrompt: "beforeSubmitPrompt";
+        postToolUse: "postToolUse";
+        postToolUseFailure: "postToolUseFailure";
+        afterAgentResponse: "afterAgentResponse";
+        afterAgentThought: "afterAgentThought";
+        stop: "stop";
+        preCompact: "preCompact";
+        sessionEnd: "sessionEnd";
+    }>;
+    conversation_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    session_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    generation_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    model: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    model_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    model_params: z.ZodOptional<z.ZodUnknown>;
+    cursor_version: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    workspace_roots: z.ZodCatch<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    user_email: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    is_background_agent: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    composer_mode: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    prompt: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    attachments: z.ZodOptional<z.ZodUnknown>;
+    tool_name: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    tool_input: z.ZodOptional<z.ZodUnknown>;
+    tool_output: z.ZodOptional<z.ZodUnknown>;
+    tool_use_id: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    cwd: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    agent_message: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    duration: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    error_message: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    failure_type: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    is_interrupt: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    status: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    duration_ms: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    message_count: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    text: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    input_tokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    output_tokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    cache_read_tokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    cache_write_tokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    loop_count: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    trigger: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    context_usage_percent: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    context_tokens: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    context_window_size: z.ZodCatch<z.ZodOptional<z.ZodNumber>>;
+    is_first_compaction: z.ZodCatch<z.ZodOptional<z.ZodBoolean>>;
+    reason: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+    final_status: z.ZodCatch<z.ZodOptional<z.ZodString>>;
+}, z.core.$strip>;
+type HookPayload = z.infer<typeof hookPayloadSchema>;
+type MapperConfig = z.infer<typeof mapperConfigSchema>;
+declare function mapHookToRaindrop(payload: HookPayload, config: MapperConfig, eventShipper: EventShipper, traceShipper: TraceShipper): Promise<void>;
+
+declare const HOOK_EVENTS: readonly ["sessionStart", "beforeSubmitPrompt", "postToolUse", "postToolUseFailure", "afterAgentResponse", "afterAgentThought", "stop", "preCompact", "sessionEnd"];
+declare const scopeSchema: z.ZodEnum<{
+    user: "user";
+    project: "project";
+}>;
+type SetupScope = z.infer<typeof scopeSchema>;
+declare const setupSchema: z.ZodObject<{
+    scope: z.ZodOptional<z.ZodEnum<{
+        user: "user";
+        project: "project";
+    }>>;
+    writeKey: z.ZodOptional<z.ZodString>;
+    userId: z.ZodOptional<z.ZodString>;
+    projectId: z.ZodOptional<z.ZodString>;
+    localOnly: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare function getCursorHooksPath(scope: SetupScope, cwd?: string): string;
+declare function runSetup(args?: z.infer<typeof setupSchema>): Promise<void>;
+declare function runUninstall(scope?: SetupScope): void;
+
+declare const PACKAGE_NAME = "@raindrop-ai/cursor";
+declare const PACKAGE_VERSION: string;
+
+declare const _debuggerResultSchema: z.ZodObject<{
+    url: z.ZodNullable<z.ZodString>;
+    autoDetected: z.ZodBoolean;
+}, z.core.$strip>;
+type LocalDebuggerResult = z.infer<typeof _debuggerResultSchema>;
+/**
+ * Detect whether the local debugger is available.
+ *
+ * Resolution order:
+ * 1. RAINDROP_LOCAL_DEBUGGER env var. use directly (no health check, trust the user)
+ * 2. Skip cache and localhost probe when CI is set or skipAutoDetect is true
+ * 3. Cached probe result (within TTL)
+ * 4. Probe http://localhost:5899/health with a short timeout
+ */
+declare function detectLocalDebugger(debug: boolean, skipAutoDetect?: boolean): Promise<LocalDebuggerResult>;
+
+declare function startMcpServer(): Promise<void>;
+
+export { EventShipper, HOOK_EVENTS, type HookPayload, type LocalDebuggerResult, type MapperConfig, PACKAGE_NAME, PACKAGE_VERSION, type RaindropConfig, type SelfDiagnosticsConfig, type SelfDiagnosticsSignalDef, type SetupScope, TraceShipper, detectLocalDebugger, getConfigPath, getCursorHooksPath, hookPayloadSchema, loadConfig, mapHookToRaindrop, runSetup, runUninstall, startMcpServer, updateConfig };