@ironflow/browser 0.1.0-test.2

package/README.md

@@ -0,0 +1,70 @@
+# @ironflow/browser
+
+Browser client for [Ironflow](https://github.com/anthropics/ironflow) workflow engine. Provides real-time subscriptions, workflow triggers, and event emission for web applications.
+
+## Installation
+
+```bash
+npm install @ironflow/browser
+```
+
+## Quick Start
+
+```typescript
+import { ironflow } from '@ironflow/browser';
+
+// Configure once at app startup
+ironflow.configure({
+  serverUrl: 'http://localhost:9123',
+});
+
+// Subscribe to events
+const sub = ironflow.subscribe('events:order.*', {
+  onEvent: (event) => console.log('Order:', event),
+});
+
+// Trigger a workflow
+const run = await ironflow.trigger('process-order', {
+  data: { orderId: '123' },
+});
+
+// Emit events
+await ironflow.emit('order.approved', { orderId: '123' });
+
+// Cleanup
+sub.unsubscribe();
+```
+
+## Features
+
+- **Real-time subscriptions** with WebSocket/ConnectRPC
+- **Workflow triggers** from the browser
+- **Event emission** for workflow coordination
+- **Auto-reconnect** with exponential backoff
+- **Type-safe** API with full TypeScript support
+
+## Key APIs
+
+| Method | Description |
+|--------|-------------|
+| `ironflow.configure(options)` | Configure the client |
+| `ironflow.connect()` | Connect to the server |
+| `ironflow.subscribe(pattern, options)` | Subscribe to events |
+| `ironflow.trigger(functionId, options)` | Trigger a workflow |
+| `ironflow.emit(eventName, data)` | Emit an event |
+| `ironflow.getRun(runId)` | Get run status |
+
+## Browser Compatibility
+
+- Chrome 80+
+- Firefox 75+
+- Safari 13.1+
+- Edge 80+
+
+## Documentation
+
+For the full API reference, see the [Browser Package Documentation](https://ironflow.dev/docs/api-reference/js-sdk/browser).
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,171 @@
+/**
+ * Ironflow Browser Client
+ *
+ * Singleton client for browser-based real-time interactions with Ironflow.
+ */
+import type { Run, ListRunsOptions, ListRunsResult, TriggerResult, EmitOptions, EmitResult, SubscriptionErrorInfo, SubscriptionCallbacks, Subscription, AckableSubscription, ConnectionState } from "@ironflow/core";
+import type { IronflowConfig, IronflowConfigOptions } from "./config.js";
+import { type BrowserSubscribeOptions, type SubscriptionGroup } from "./subscription.js";
+/**
+ * Ironflow browser client singleton
+ */
+declare class IronflowClient {
+    private config;
+    private logger;
+    private transport;
+    private subscriptionManager;
+    private visibilityHandler;
+    /**
+     * Configure the client
+     *
+     * Must be called before any other operations.
+     */
+    configure(options?: IronflowConfigOptions): void;
+    /**
+     * Check if the client is configured
+     */
+    get isConfigured(): boolean;
+    /**
+     * Detect which transport the server supports
+     *
+     * Returns the best available transport based on server capabilities.
+     * ConnectRPC is preferred over WebSocket.
+     *
+     * @example
+     * ```typescript
+     * const transport = await ironflow.detectTransport();
+     * // Returns 'connectrpc' | 'websocket'
+     * ```
+     */
+    detectTransport(): Promise<"connectrpc" | "websocket">;
+    /**
+     * Get the current configuration
+     */
+    getConfig(): IronflowConfig;
+    /**
+     * Connect to the Ironflow server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the Ironflow server
+     */
+    disconnect(): void;
+    /**
+     * Register a callback for connection state changes
+     */
+    onConnectionChange(callback: (state: ConnectionState) => void): () => void;
+    /**
+     * Get current connection state
+     */
+    get connectionState(): ConnectionState;
+    /**
+     * Subscribe to events matching a pattern
+     *
+     * @example
+     * ```typescript
+     * // Basic subscription
+     * const sub = await ironflow.subscribe('events:order.*', {
+     *   onEvent: (event) => console.log(event),
+     * });
+     *
+     * // Multiple patterns
+     * const sub = await ironflow.subscribe(['system.run.*', 'events:order.*'], {
+     *   onEvent: (event) => { ... }
+     * });
+     *
+     * // With options
+     * const sub = await ironflow.subscribe('events:*', {
+     *   onEvent: (e) => { ... },
+     *   replay: 10,
+     *   trackState: true,
+     *   ackMode: 'manual',
+     * });
+     * ```
+     */
+    subscribe<T = unknown>(pattern: string | string[], callbacksAndOptions: SubscriptionCallbacks<T> & BrowserSubscribeOptions): Promise<Subscription | AckableSubscription>;
+    /**
+     * Create a subscription group for batch management
+     *
+     * @example
+     * ```typescript
+     * const group = ironflow.subscriptionGroup();
+     * await group.add('system.run.*', { onEvent: handleRun });
+     * await group.add('events:payment.*', { onEvent: handlePayment });
+     * // Later:
+     * group.unsubscribeAll();
+     * ```
+     */
+    subscriptionGroup(): SubscriptionGroup;
+    /**
+     * Register a global error handler
+     */
+    onError(callback: (error: SubscriptionErrorInfo) => void): () => void;
+    /**
+     * Trigger a workflow
+     *
+     * @example
+     * ```typescript
+     * const run = await ironflow.trigger<OrderInput, OrderOutput>('process-order', {
+     *   data: { orderId: '123' }
+     * });
+     * ```
+     */
+    trigger<TInput = unknown>(functionId: string, options: {
+        data: TInput;
+    }): Promise<TriggerResult>;
+    /**
+     * Get run status
+     */
+    getRun(runId: string): Promise<Run>;
+    /**
+     * List runs with filtering
+     */
+    listRuns(options?: ListRunsOptions): Promise<ListRunsResult>;
+    /**
+     * Cancel a running run
+     */
+    cancelRun(runId: string, reason?: string): Promise<Run>;
+    /**
+     * Emit an event
+     *
+     * @example
+     * ```typescript
+     * await ironflow.emit('order.approved', {
+     *   orderId: '123',
+     *   approvedBy: 'user@example.com'
+     * });
+     * ```
+     */
+    emit(eventName: string, data: unknown, options?: EmitOptions): Promise<EmitResult>;
+    /**
+     * Join a consumer group for load-balanced event processing
+     */
+    joinConsumerGroup<T = unknown>(groupName: string, pattern: string, callbacksAndOptions: SubscriptionCallbacks<T> & BrowserSubscribeOptions): Promise<AckableSubscription>;
+    /**
+     * Pattern helpers for building subscription patterns
+     */
+    static patterns: {
+        readonly allRuns: () => string;
+        readonly run: (runId: string) => string;
+        readonly runLifecycle: (runId: string) => string;
+        readonly runSteps: (runId: string) => string;
+        readonly allFunctions: () => string;
+        readonly function: (functionId: string) => string;
+        readonly userEvent: (eventName: string) => string;
+        readonly allUserEvents: () => string;
+    };
+    private ensureConfigured;
+    private cleanup;
+    private setupVisibilityHandling;
+    private request;
+    private mapRunResponse;
+}
+/**
+ * Singleton instance
+ */
+export declare const ironflow: IronflowClient;
+/**
+ * Export the class for advanced usage
+ */
+export { IronflowClient };
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"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"}

package/dist/client.js

@@ -0,0 +1,443 @@
+/**
+ * Ironflow Browser Client
+ *
+ * Singleton client for browser-based real-time interactions with Ironflow.
+ */
+import { NotConfiguredError, IronflowError, ValidationError, createLogger, createNoopLogger, DEFAULT_TIMEOUTS, TriggerResponseSchema, RunResponseSchema, ListRunsResponseSchema, RunStatusSchema, ErrorResponseSchema, safeJsonParse, patterns, } from "@ironflow/core";
+import { mergeConfig } from "./config.js";
+import { SubscriptionManager, } from "./subscription.js";
+import { createWebSocketTransport } from "./transport/websocket.js";
+import { createConnectRPCTransport } from "./transport/connectrpc.js";
+/**
+ * Ironflow browser client singleton
+ */
+class IronflowClient {
+    config = null;
+    logger = createNoopLogger();
+    transport = null;
+    subscriptionManager = null;
+    visibilityHandler = null;
+    /**
+     * Configure the client
+     *
+     * Must be called before any other operations.
+     */
+    configure(options = {}) {
+        this.config = mergeConfig(options);
+        // Set up logger
+        if (this.config.logger === false) {
+            this.logger = createNoopLogger();
+        }
+        else if (this.config.logger) {
+            this.logger = this.config.logger;
+        }
+        else {
+            this.logger = createLogger({ prefix: "[ironflow]" });
+        }
+        // Clean up existing resources
+        this.cleanup();
+        // Create transport
+        const transportOptions = {
+            auth: this.config.auth,
+            autoReconnect: this.config.reconnect.enabled,
+            reconnectDelay: this.config.reconnect.backoff.initial,
+            maxReconnectDelay: this.config.reconnect.backoff.max,
+            reconnectBackoff: this.config.reconnect.backoff.multiplier,
+        };
+        // Create transport based on config (ConnectRPC by default)
+        if (this.config.transport === "websocket") {
+            this.transport = createWebSocketTransport(this.config.serverUrl, transportOptions);
+        }
+        else {
+            // Default to ConnectRPC
+            this.transport = createConnectRPCTransport(this.config.serverUrl, transportOptions);
+        }
+        // Create subscription manager
+        this.subscriptionManager = new SubscriptionManager(this.transport, this.config.logger);
+        // Set up visibility handling
+        if (this.config.visibility.pauseOnHidden && typeof document !== "undefined") {
+            this.setupVisibilityHandling();
+        }
+        this.logger.info("Ironflow client configured", {
+            serverUrl: this.config.serverUrl,
+            transport: this.config.transport,
+        });
+    }
+    /**
+     * Check if the client is configured
+     */
+    get isConfigured() {
+        return this.config !== null;
+    }
+    /**
+     * Detect which transport the server supports
+     *
+     * Returns the best available transport based on server capabilities.
+     * ConnectRPC is preferred over WebSocket.
+     *
+     * @example
+     * ```typescript
+     * const transport = await ironflow.detectTransport();
+     * // Returns 'connectrpc' | 'websocket'
+     * ```
+     */
+    async detectTransport() {
+        const serverUrl = this.config?.serverUrl ?? "http://localhost:9123";
+        try {
+            // Try to get server capabilities via ConnectRPC endpoint
+            const response = await fetch(`${serverUrl}/ironflow.v1.IronflowService/GetCapabilities`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: "{}",
+            });
+            if (response.ok) {
+                const data = await response.json();
+                const transports = data.transports;
+                // Check if server explicitly supports connectrpc
+                if (transports?.includes("connectrpc") || transports?.includes("grpc")) {
+                    return "connectrpc";
+                }
+                // Server responded, so ConnectRPC endpoint works
+                return "connectrpc";
+            }
+        }
+        catch {
+            // ConnectRPC not available
+        }
+        // Fall back to WebSocket
+        return "websocket";
+    }
+    /**
+     * Get the current configuration
+     */
+    getConfig() {
+        if (!this.config) {
+            throw new NotConfiguredError();
+        }
+        return this.config;
+    }
+    // ============================================================================
+    // Connection Management
+    // ============================================================================
+    /**
+     * Connect to the Ironflow server
+     */
+    async connect() {
+        this.ensureConfigured();
+        await this.subscriptionManager.connect();
+    }
+    /**
+     * Disconnect from the Ironflow server
+     */
+    disconnect() {
+        if (this.subscriptionManager) {
+            this.subscriptionManager.disconnect();
+        }
+    }
+    /**
+     * Register a callback for connection state changes
+     */
+    onConnectionChange(callback) {
+        this.ensureConfigured();
+        return this.subscriptionManager.onConnectionChange(callback);
+    }
+    /**
+     * Get current connection state
+     */
+    get connectionState() {
+        if (!this.subscriptionManager) {
+            return "disconnected";
+        }
+        return this.subscriptionManager.connectionState;
+    }
+    // ============================================================================
+    // Subscriptions
+    // ============================================================================
+    /**
+     * Subscribe to events matching a pattern
+     *
+     * @example
+     * ```typescript
+     * // Basic subscription
+     * const sub = await ironflow.subscribe('events:order.*', {
+     *   onEvent: (event) => console.log(event),
+     * });
+     *
+     * // Multiple patterns
+     * const sub = await ironflow.subscribe(['system.run.*', 'events:order.*'], {
+     *   onEvent: (event) => { ... }
+     * });
+     *
+     * // With options
+     * const sub = await ironflow.subscribe('events:*', {
+     *   onEvent: (e) => { ... },
+     *   replay: 10,
+     *   trackState: true,
+     *   ackMode: 'manual',
+     * });
+     * ```
+     */
+    subscribe(pattern, callbacksAndOptions) {
+        this.ensureConfigured();
+        return this.subscriptionManager.subscribe(pattern, callbacksAndOptions);
+    }
+    /**
+     * Create a subscription group for batch management
+     *
+     * @example
+     * ```typescript
+     * const group = ironflow.subscriptionGroup();
+     * await group.add('system.run.*', { onEvent: handleRun });
+     * await group.add('events:payment.*', { onEvent: handlePayment });
+     * // Later:
+     * group.unsubscribeAll();
+     * ```
+     */
+    subscriptionGroup() {
+        this.ensureConfigured();
+        return this.subscriptionManager.createGroup();
+    }
+    /**
+     * Register a global error handler
+     */
+    onError(callback) {
+        this.ensureConfigured();
+        return this.subscriptionManager.onError(callback);
+    }
+    // ============================================================================
+    // Workflow Operations
+    // ============================================================================
+    /**
+     * Trigger a workflow
+     *
+     * @example
+     * ```typescript
+     * const run = await ironflow.trigger<OrderInput, OrderOutput>('process-order', {
+     *   data: { orderId: '123' }
+     * });
+     * ```
+     */
+    async trigger(functionId, options) {
+        this.ensureConfigured();
+        const response = await this.request(TriggerResponseSchema, "POST", "/ironflow.v1.IronflowService/Trigger", {
+            event: functionId,
+            data: options.data,
+        });
+        return {
+            runIds: response.runIds ?? [],
+            eventId: response.eventId,
+        };
+    }
+    /**
+     * Get run status
+     */
+    async getRun(runId) {
+        this.ensureConfigured();
+        const response = await this.request(RunResponseSchema, "POST", "/ironflow.v1.IronflowService/GetRun", { id: runId });
+        return this.mapRunResponse(response);
+    }
+    /**
+     * List runs with filtering
+     */
+    async listRuns(options) {
+        this.ensureConfigured();
+        const response = await this.request(ListRunsResponseSchema, "POST", "/ironflow.v1.IronflowService/ListRuns", {
+            function_id: options?.functionId,
+            status: options?.status?.toUpperCase(),
+            limit: options?.limit,
+            cursor: options?.cursor,
+        });
+        return {
+            runs: (response.runs ?? []).map((r) => this.mapRunResponse(r)),
+            nextCursor: response.nextCursor,
+            totalCount: response.totalCount ?? 0,
+        };
+    }
+    /**
+     * Cancel a running run
+     */
+    async cancelRun(runId, reason) {
+        this.ensureConfigured();
+        const response = await this.request(RunResponseSchema, "POST", "/ironflow.v1.IronflowService/CancelRun", { id: runId, reason });
+        return this.mapRunResponse(response);
+    }
+    // ============================================================================
+    // Event Emission
+    // ============================================================================
+    /**
+     * Emit an event
+     *
+     * @example
+     * ```typescript
+     * await ironflow.emit('order.approved', {
+     *   orderId: '123',
+     *   approvedBy: 'user@example.com'
+     * });
+     * ```
+     */
+    async emit(eventName, data, options) {
+        this.ensureConfigured();
+        const response = await this.request(TriggerResponseSchema, "POST", "/ironflow.v1.PubSubService/Emit", {
+            event: eventName,
+            data,
+            idempotency_key: options?.idempotencyKey,
+            metadata: options?.metadata,
+            namespace: options?.namespace,
+        });
+        return {
+            runIds: response.runIds ?? [],
+            eventId: response.eventId,
+        };
+    }
+    // ============================================================================
+    // Consumer Groups
+    // ============================================================================
+    /**
+     * Join a consumer group for load-balanced event processing
+     */
+    async joinConsumerGroup(groupName, pattern, callbacksAndOptions) {
+        this.ensureConfigured();
+        const sub = await this.subscribe(pattern, {
+            ...callbacksAndOptions,
+            consumerGroup: groupName,
+            ackMode: "manual",
+        });
+        return sub;
+    }
+    // ============================================================================
+    // Pattern Helpers (static)
+    // ============================================================================
+    /**
+     * Pattern helpers for building subscription patterns
+     */
+    static patterns = patterns;
+    // ============================================================================
+    // Internal Methods
+    // ============================================================================
+    ensureConfigured() {
+        if (!this.config) {
+            throw new NotConfiguredError();
+        }
+    }
+    cleanup() {
+        if (this.visibilityHandler) {
+            document.removeEventListener("visibilitychange", this.visibilityHandler);
+            this.visibilityHandler = null;
+        }
+        if (this.subscriptionManager) {
+            this.subscriptionManager.disconnect();
+            this.subscriptionManager = null;
+        }
+        this.transport = null;
+    }
+    setupVisibilityHandling() {
+        this.visibilityHandler = () => {
+            if (document.hidden) {
+                this.logger.debug("Tab hidden, pausing subscriptions");
+                this.subscriptionManager?.pause();
+            }
+            else {
+                if (this.config?.visibility.reconnectOnVisible) {
+                    this.logger.debug("Tab visible, resuming subscriptions");
+                    this.subscriptionManager?.resume();
+                }
+            }
+        };
+        document.addEventListener("visibilitychange", this.visibilityHandler);
+    }
+    async request(schema, method, path, body) {
+        const url = `${this.config.serverUrl}${path}`;
+        const timeout = this.config.timeout ?? DEFAULT_TIMEOUTS.CLIENT;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const headers = {
+                "Content-Type": "application/json",
+            };
+            if (this.config.auth?.apiKey) {
+                headers["Authorization"] = `Bearer ${this.config.auth.apiKey}`;
+            }
+            else if (this.config.auth?.token) {
+                headers["Authorization"] = `Bearer ${this.config.auth.token}`;
+            }
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: JSON.stringify(body),
+                signal: controller.signal,
+            });
+            const responseBody = await response.text();
+            if (!response.ok) {
+                const errorResult = ErrorResponseSchema.safeParse(safeJsonParse(responseBody));
+                const errorData = errorResult.success
+                    ? errorResult.data
+                    : { message: responseBody };
+                throw new IronflowError(errorData.message ?? `Request failed: ${response.status}`, {
+                    code: errorData.code ?? `HTTP_${response.status}`,
+                    retryable: response.status >= 500,
+                });
+            }
+            const parsed = safeJsonParse(responseBody);
+            if (parsed === undefined) {
+                throw new ValidationError("Invalid JSON response from server");
+            }
+            const result = schema.safeParse(parsed);
+            if (!result.success) {
+                const issues = result.error.issues
+                    .map((i) => `${i.path.join(".")}: ${i.message}`)
+                    .join(", ");
+                throw new ValidationError(`Invalid response from server: ${issues}`);
+            }
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof IronflowError || error instanceof ValidationError) {
+                throw error;
+            }
+            if (error instanceof Error && error.name === "AbortError") {
+                throw new IronflowError(`Request timeout after ${timeout}ms`, {
+                    code: "TIMEOUT",
+                    retryable: true,
+                });
+            }
+            throw new IronflowError(error instanceof Error ? error.message : "Request failed", {
+                code: "REQUEST_FAILED",
+                retryable: true,
+                cause: error instanceof Error ? error : undefined,
+            });
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    mapRunResponse(response) {
+        const statusResult = RunStatusSchema.safeParse(response.status.toLowerCase());
+        const status = statusResult.success ? statusResult.data : "failed";
+        return {
+            id: response.id,
+            functionId: response.functionId,
+            eventId: response.eventId,
+            status,
+            attempt: response.attempt,
+            maxAttempts: response.maxAttempts,
+            input: response.input,
+            output: response.output,
+            error: response.error,
+            startedAt: response.startedAt ? new Date(response.startedAt) : undefined,
+            endedAt: response.endedAt ? new Date(response.endedAt) : undefined,
+            createdAt: new Date(response.createdAt),
+            updatedAt: new Date(response.updatedAt),
+        };
+    }
+}
+/**
+ * Singleton instance
+ */
+export const ironflow = new IronflowClient();
+/**
+ * Export the class for advanced usage
+ */
+export { IronflowClient };
+//# sourceMappingURL=client.js.map