cloudcruise 0.0.4 → 1.0.0

package/dist/runs/types.d.ts

@@ -1,155 +0,0 @@
-/**
- * CloudCruise Runs API Type Definitions
- */
-import type { EventType, RunEventMessage, EventPayloadMap, ExecutionQueuedPayload, ExecutionStartPayload, ExecutionStepPayload, InteractionWaitingPayload, InteractionFinishedPayload, AgentErrorAnalysisPayload, ExecutionRequeuedPayload, EndRunPayload, EndRunError, ExecutionStoppedEarlyPayload, FileUploadedPayload, ScreenshotUploadedPayload } from '../events/types.js';
-export type { EventType };
-export type { ExecutionQueuedPayload, ExecutionStartPayload, ExecutionStepPayload, InteractionWaitingPayload, InteractionFinishedPayload, AgentErrorAnalysisPayload, ExecutionRequeuedPayload, EndRunPayload, EndRunError, ExecutionStoppedEarlyPayload, FileUploadedPayload, ScreenshotUploadedPayload, EventPayloadMap, };
-export interface DryRun {
-    enabled: boolean;
-    add_to_output?: Record<string, any>;
-}
-export interface Metadata {
-    metadata: Record<string, any>;
-}
-export interface RunSpecificWebhook {
-    url: string;
-    event_types_subscribed: EventType[];
-    secret: string;
-    validity: number;
-}
-export type PayloadWebhook = Metadata | RunSpecificWebhook;
-export interface StartRunRequest {
-    workflow_id: string;
-    run_input_variables: Record<string, any>;
-    dry_run?: DryRun;
-    webhook?: PayloadWebhook;
-    additional_context?: Record<string, any>;
-    client_id?: string;
-}
-export interface StartRunResponse {
-    session_id: string;
-}
-export type UserInteractionData = Record<string, any>;
-export interface VideoUrl {
-    timestamp: string;
-    session_id: string;
-    signed_screen_recording_url: string;
-    signed_screen_recording_url_expires: string;
-}
-export interface RunError {
-    prompt?: string | null;
-    message?: string | null;
-    error_id?: string | null;
-    full_url?: string | null;
-    llm_model?: string | null;
-    created_at?: string | null;
-    error_code?: string | null;
-    action_type?: string | null;
-    action_display_name?: string | null;
-}
-export interface SignedFileUrl {
-    signed_file_url: string;
-    file_name: string;
-    timestamp: string;
-    signed_file_url_expires: string;
-    metadata: Record<string, any>;
-}
-export interface SignedScreenshotUrl {
-    signed_screenshot_url: string;
-    node_display_name: string;
-    timestamp: string;
-    signed_screenshot_url_expires: string;
-    error_screenshot: boolean;
-    full_length_screenshot?: boolean;
-    retry_index?: number;
-}
-export interface WorkflowError {
-    message: string;
-    error_id: string;
-    full_url?: string | null;
-    created_at?: string | null;
-    error_code?: string | null;
-    action_type?: string | null;
-    action_display_name?: string | null;
-}
-export interface RunResult {
-    session_id: string;
-    status: EventType;
-    input_variables: Record<string, any>;
-    data: Record<string, any>;
-    video_urls: VideoUrl[];
-    file_urls: SignedFileUrl[];
-    screenshot_urls: SignedScreenshotUrl[];
-    errors: RunError[] | null;
-}
-export interface GetRunResult {
-    data: Record<string, any> | null;
-    session_id: string;
-    errors: WorkflowError[];
-    status: EventType;
-    input_variables: Record<string, any>;
-    workflow_id: string | null;
-    session_retries: number | null;
-    encrypted_variables: string[] | null;
-    video_urls: VideoUrl[] | null;
-    screenshot_urls?: SignedScreenshotUrl[] | null;
-    file_urls: SignedFileUrl[] | null;
-}
-export interface WebhookEvent {
-    success: boolean;
-    response: string;
-    error: string;
-}
-export interface WebhookReplayResponse {
-    status: string;
-    info: string;
-    nr_success: number;
-    nr_failed: number;
-    webhook_events: WebhookEvent[];
-}
-/**
- * Streaming (SSE) types
- */
-export type SseEventName = 'run.event' | 'ping';
-export type RunEventEnvelope<E extends EventType = EventType> = RunEventMessage<E>;
-export interface PingEnvelope {
-    event: 'ping';
-    data: {
-        ts: number;
-    } | Record<string, any>;
-}
-export type SseMessage<E extends EventType = EventType> = RunEventEnvelope<E> | PingEnvelope;
-export interface RunStreamOptions {
-    signal?: AbortSignal;
-    withCredentials?: boolean;
-    headers?: Record<string, string>;
-    reconnect?: {
-        enabled?: boolean;
-        delays?: number[];
-        jitter?: number;
-    };
-}
-export type RunEventMap = {
-    [K in EventType]: RunEventEnvelope<K>;
-};
-export type RunHandleEventMap = {
-    'open': undefined;
-    'close': undefined;
-    'reconnect': {
-        attemptDelayMs: number;
-    };
-    'error': unknown;
-    'end': {
-        type: EventType;
-    };
-    'run.event': SseMessage;
-    'ping': PingEnvelope;
-    'message': SseMessage | PingEnvelope;
-} & RunEventMap;
-export interface RunHandle {
-    sessionId: string;
-    on<K extends keyof RunHandleEventMap>(event: K, handler: (e: RunHandleEventMap[K]) => void): () => void;
-    wait(): Promise<GetRunResult>;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<SseMessage>;
-}

package/dist/runs/types.js

@@ -1,4 +0,0 @@
-/**
- * CloudCruise Runs API Type Definitions
- */
-export {};

package/dist/utils/asyncQueue.d.ts

@@ -1,9 +0,0 @@
-export declare class AsyncEventQueue<T> implements AsyncIterable<T> {
-    private items;
-    private pending;
-    private done;
-    push(item: T): void;
-    close(): void;
-    next(): Promise<IteratorResult<T>>;
-    [Symbol.asyncIterator](): AsyncIterator<T>;
-}

package/dist/utils/asyncQueue.js

@@ -1,43 +0,0 @@
-export class AsyncEventQueue {
-    items = [];
-    pending = null;
-    done = false;
-    push(item) {
-        if (this.done)
-            return;
-        if (this.pending) {
-            const resolve = this.pending;
-            this.pending = null;
-            resolve({ value: item, done: false });
-        }
-        else {
-            this.items.push(item);
-        }
-    }
-    close() {
-        if (this.done)
-            return;
-        this.done = true;
-        if (this.pending) {
-            const resolve = this.pending;
-            this.pending = null;
-            resolve({ value: undefined, done: true });
-        }
-    }
-    async next() {
-        if (this.items.length) {
-            return { value: this.items.shift(), done: false };
-        }
-        if (this.done) {
-            return { value: undefined, done: true };
-        }
-        return await new Promise(resolve => {
-            this.pending = resolve;
-        });
-    }
-    [Symbol.asyncIterator]() {
-        return {
-            next: () => this.next(),
-        };
-    }
-}

package/dist/utils/connectionManager.d.ts

@@ -1,29 +0,0 @@
-import type { SseMessage } from '../runs/types.js';
-type Listener = (e: unknown) => void;
-interface SubscribeOptions {
-    signal?: AbortSignal;
-}
-export interface SessionSubscription {
-    on(event: string, handler: Listener): () => void;
-    close(): void;
-    [Symbol.asyncIterator](): AsyncIterator<SseMessage>;
-}
-export declare class ConnectionManager {
-    private readonly baseUrl;
-    private readonly apiKey;
-    private clientId;
-    private conn;
-    private connecting;
-    private connected;
-    private reconnecting;
-    private readonly reconnectDelays;
-    private readonly sessions;
-    constructor(baseUrl: string, apiKey: string);
-    ensureClientId(): Promise<string>;
-    private generateClientId;
-    connectIfNeeded(): Promise<void>;
-    subscribe(sessionId: string, opts?: SubscribeOptions): SessionSubscription;
-    private openMuxConnection;
-    private scheduleReconnect;
-}
-export {};

package/dist/utils/connectionManager.js

@@ -1,234 +0,0 @@
-import { openSSE } from './sse.js';
-import { SimpleEventEmitter } from './events.js';
-import { AsyncEventQueue } from './asyncQueue.js';
-import { EventType } from '../events/types.js';
-function isFinalEvent(eventType) {
-    return (eventType === EventType.ExecutionSuccess ||
-        eventType === EventType.ExecutionFailed ||
-        eventType === EventType.ExecutionStopped);
-}
-export class ConnectionManager {
-    baseUrl;
-    apiKey;
-    clientId;
-    conn = null;
-    connecting = false;
-    connected = false;
-    reconnecting = false;
-    reconnectDelays = [1000, 3000, 10000];
-    sessions = new Map();
-    constructor(baseUrl, apiKey) {
-        this.baseUrl = baseUrl.replace(/\/$/, '');
-        this.apiKey = apiKey;
-    }
-    async ensureClientId() {
-        if (this.clientId)
-            return this.clientId;
-        this.clientId = this.generateClientId();
-        return this.clientId;
-    }
-    /*
-    try to use crypto.randomUUID if the platform is supported. otherwise fallback to other methods: https://stackoverflow.com/questions/105034/how-do-i-create-a-guid-uuid/2117523#2117523
-    */
-    generateClientId() {
-        const cryptoObj = globalThis.crypto;
-        // Preferred: native CSPRNG-backed UUID
-        if (cryptoObj?.randomUUID) {
-            return cryptoObj.randomUUID();
-        }
-        // Fallback: RFC4122 v4 built from CSPRNG bytes
-        if (cryptoObj?.getRandomValues) {
-            const bytes = new Uint8Array(16);
-            cryptoObj.getRandomValues(bytes);
-            bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
-            bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 10xx
-            const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, '0'));
-            return `${hex.slice(0, 4).join('')}-${hex.slice(4, 6).join('')}-${hex.slice(6, 8).join('')}-${hex.slice(8, 10).join('')}-${hex.slice(10).join('')}`;
-        }
-        // Last resort: non-CSPRNG timestamp + Math.random
-        let d = Date.now();
-        let d2 = typeof performance !== 'undefined' && typeof performance.now === 'function'
-            ? Math.floor(performance.now() * 1000)
-            : 0;
-        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
-            let r = Math.random() * 16;
-            if (d > 0) {
-                r = ((d + r) % 16) | 0;
-                d = Math.floor(d / 16);
-            }
-            else {
-                r = ((d2 + r) % 16) | 0;
-                d2 = Math.floor(d2 / 16);
-            }
-            const v = c === 'x' ? r : (r & 0x3) | 0x8;
-            return v.toString(16);
-        });
-    }
-    async connectIfNeeded() {
-        if (this.connected || this.connecting)
-            return;
-        if (!this.clientId)
-            await this.ensureClientId();
-        await this.openMuxConnection();
-    }
-    subscribe(sessionId, opts) {
-        // Kick off connection if not already connected
-        try {
-            void this.connectIfNeeded();
-        }
-        catch { }
-        // Ensure channel exists
-        let channel = this.sessions.get(sessionId);
-        if (!channel) {
-            channel = {
-                sessionId,
-                emitter: new SimpleEventEmitter(),
-                subscribers: new Set(),
-                ended: false
-            };
-            this.sessions.set(sessionId, channel);
-        }
-        // Create per-handle queue
-        const queue = new AsyncEventQueue();
-        channel.subscribers.add(queue);
-        // Propagate abort to handle close
-        if (opts?.signal) {
-            const onAbort = () => sub.close();
-            opts.signal.addEventListener('abort', onAbort, { once: true });
-        }
-        const sub = {
-            on: (event, handler) => channel.emitter.on(event, handler),
-            close: () => {
-                if (!channel)
-                    return;
-                queue.close();
-                channel.subscribers.delete(queue);
-                // If no more subscribers and channel is ended, remove it
-                if (channel.subscribers.size === 0 && channel.ended) {
-                    this.sessions.delete(sessionId);
-                }
-            },
-            [Symbol.asyncIterator]() {
-                return queue[Symbol.asyncIterator]();
-            }
-        };
-        return sub;
-    }
-    async openMuxConnection() {
-        if (this.connecting || this.connected)
-            return;
-        if (!this.clientId)
-            await this.ensureClientId();
-        this.connecting = true;
-        const headers = {
-            'cc-key': this.apiKey
-        };
-        const url = `${this.baseUrl}/run/clients/${this.clientId}/events`;
-        const emitAll = (event, payload) => {
-            for (const ch of this.sessions.values()) {
-                ch.emitter.emit(event, payload);
-            }
-        };
-        try {
-            this.conn = openSSE(url, {
-                onOpen: () => {
-                    this.connected = true;
-                    this.connecting = false;
-                    emitAll('open');
-                },
-                onEvent: (evt) => {
-                    if (evt.event === 'ping') {
-                        emitAll('ping', evt);
-                        return;
-                    }
-                    if (evt.event === 'run.event') {
-                        const raw = evt;
-                        const data = raw.data?.data;
-                        if (!data) {
-                            return;
-                        }
-                        // Extract session_id - it's always present in payload
-                        const payload = data.payload;
-                        const sessionId = payload?.session_id;
-                        if (!sessionId) {
-                            return;
-                        }
-                        const channel = this.sessions.get(sessionId);
-                        if (!channel) {
-                            return;
-                        }
-                        const msg = {
-                            event: 'run.event',
-                            data: data,
-                            timestamp: raw.timestamp || new Date().toISOString(),
-                            expires_at: raw.expires_at || new Date(Date.now() + 3600000).toISOString()
-                        };
-                        // fan-out to all subscribers
-                        for (const q of channel.subscribers)
-                            q.push(msg);
-                        channel.emitter.emit('run.event', msg);
-                        const eventType = data.event;
-                        if (isFinalEvent(eventType)) {
-                            channel.ended = true;
-                            channel.emitter.emit('end', { type: eventType });
-                            for (const q of channel.subscribers)
-                                q.close();
-                            channel.subscribers.clear();
-                            // Remove the channel after notifying
-                            this.sessions.delete(sessionId);
-                        }
-                        return;
-                    }
-                    const u = evt;
-                },
-                onError: (err) => {
-                    // Surface error to all channels and attempt reconnect
-                    emitAll('error', err);
-                    if (!this.reconnecting)
-                        this.scheduleReconnect();
-                },
-                onClose: () => {
-                    this.connected = false;
-                    this.connecting = false;
-                    emitAll('close');
-                    if (!this.reconnecting)
-                        this.scheduleReconnect();
-                }
-            }, {
-                headers,
-                withCredentials: false
-            });
-        }
-        catch (e) {
-            this.connected = false;
-            this.connecting = false;
-            if (!this.reconnecting)
-                this.scheduleReconnect();
-        }
-    }
-    scheduleReconnect() {
-        if (this.reconnecting)
-            return;
-        this.reconnecting = true;
-        (async () => {
-            for (const delay of this.reconnectDelays) {
-                // Notify listeners about reconnect attempt
-                for (const ch of this.sessions.values())
-                    ch.emitter.emit('reconnect', { attemptDelayMs: delay });
-                await new Promise(r => setTimeout(r, delay));
-                try {
-                    await this.openMuxConnection();
-                    if (this.connected) {
-                        this.reconnecting = false;
-                        return;
-                    }
-                }
-                catch {
-                    // continue to next delay
-                }
-            }
-            // Give up after exhausting delays; next event/subscribe will try again
-            this.reconnecting = false;
-        })();
-    }
-}

package/dist/utils/env.d.ts

@@ -1,2 +0,0 @@
-export type CloudCruiseEnvVar = 'CLOUDCRUISE_API_KEY' | 'CLOUDCRUISE_BASE_URL' | 'CLOUDCRUISE_ENCRYPTION_KEY';
-export declare function getEnv(key: CloudCruiseEnvVar): string | undefined;

package/dist/utils/env.js

@@ -1,9 +0,0 @@
-export function getEnv(key) {
-    if (typeof process !== 'undefined' && process.env && process.env[key]) {
-        return process.env[key];
-    }
-    else if (typeof globalThis !== 'undefined' && globalThis[key]) {
-        return globalThis[key];
-    }
-    return undefined;
-}

package/dist/utils/events.d.ts

@@ -1,24 +0,0 @@
-export type EventHandler<T = unknown> = (event: T) => void;
-/**
- * Event emitter that supports both typed and untyped usage.
- *
- * - Use without type parameter for untyped events (backward compatible)
- * - Use with EventMap type parameter for type-safe events
- *
- * @example
- * // Untyped usage
- * const emitter = new SimpleEventEmitter();
- * emitter.on('foo', (data) => console.log(data));
- *
- * @example
- * // Typed usage
- * type Events = { foo: string; bar: number };
- * const emitter = new SimpleEventEmitter<Events>();
- * emitter.on('foo', (data) => console.log(data)); // data is string
- */
-export declare class SimpleEventEmitter<EventMap extends Record<string, any> = Record<string, unknown>> {
-    private listeners;
-    on<K extends keyof EventMap>(event: K, handler: EventHandler<EventMap[K]>): () => void;
-    emit<K extends keyof EventMap>(event: K, payload: EventMap[K]): void;
-    clear(): void;
-}

package/dist/utils/events.js

@@ -1,40 +0,0 @@
-/**
- * Event emitter that supports both typed and untyped usage.
- *
- * - Use without type parameter for untyped events (backward compatible)
- * - Use with EventMap type parameter for type-safe events
- *
- * @example
- * // Untyped usage
- * const emitter = new SimpleEventEmitter();
- * emitter.on('foo', (data) => console.log(data));
- *
- * @example
- * // Typed usage
- * type Events = { foo: string; bar: number };
- * const emitter = new SimpleEventEmitter<Events>();
- * emitter.on('foo', (data) => console.log(data)); // data is string
- */
-export class SimpleEventEmitter {
-    listeners = new Map();
-    on(event, handler) {
-        if (!this.listeners.has(event))
-            this.listeners.set(event, new Set());
-        this.listeners.get(event).add(handler);
-        return () => {
-            const set = this.listeners.get(event);
-            if (set)
-                set.delete(handler);
-        };
-    }
-    emit(event, payload) {
-        const set = this.listeners.get(event);
-        if (!set)
-            return;
-        for (const handler of set)
-            handler(payload);
-    }
-    clear() {
-        this.listeners.clear();
-    }
-}

package/dist/utils/sse.d.ts

@@ -1,24 +0,0 @@
-export interface SSEHandlers {
-    onOpen?: () => void;
-    onEvent?: (evt: {
-        event: string;
-        data?: unknown;
-        id?: string;
-        raw?: string;
-    }) => void;
-    onError?: (error: Error) => void;
-    onClose?: () => void;
-}
-export interface SSEOptions {
-    headers?: HeadersInit;
-    withCredentials?: boolean;
-    signal?: AbortSignal;
-}
-export interface SSEConnection {
-    close(): void;
-}
-/**
- * Open an SSE connection using either native EventSource (browser, cookie auth)
- * or fetch streaming (Node 18+ and modern browsers) when custom headers are needed.
- */
-export declare function openSSE(url: string, handlers: SSEHandlers, opts?: SSEOptions): SSEConnection;