@qontinui/ui-bridge 0.1.1

package/dist/types-DdJD9yw5.d.mts

@@ -0,0 +1,354 @@
+import { a as ActionRequest, b as ActionResponse, a0 as WaitOptions, h as ElementState } from './types-BpvpStn3.mjs';
+
+/**
+ * Control Module Types
+ *
+ * Types for the control protocol and action execution.
+ */
+
+/**
+ * Extended action request with additional options
+ */
+interface ControlActionRequest extends ActionRequest {
+    /** Unique request ID for tracking */
+    requestId?: string;
+    /** Capture snapshot after action */
+    captureAfter?: boolean;
+    /** Retry options if action fails */
+    retryOptions?: {
+        maxRetries: number;
+        retryDelay: number;
+        retryOn?: ('timeout' | 'notFound' | 'disabled' | 'error')[];
+    };
+}
+/**
+ * Extended action response with additional info
+ */
+interface ControlActionResponse extends ActionResponse {
+    /** Request ID if provided */
+    requestId?: string;
+    /** Snapshot captured after action */
+    snapshot?: unknown;
+    /** Number of retries attempted */
+    retryCount?: number;
+    /** Wait duration before action */
+    waitDurationMs?: number;
+}
+/**
+ * Component action request
+ */
+interface ComponentActionRequest {
+    /** Action ID to execute */
+    action: string;
+    /** Action parameters */
+    params?: Record<string, unknown>;
+    /** Unique request ID */
+    requestId?: string;
+}
+/**
+ * Component action response
+ */
+interface ComponentActionResponse {
+    /** Whether the action succeeded */
+    success: boolean;
+    /** Result from the action */
+    result?: unknown;
+    /** Error message if failed */
+    error?: string;
+    /** Stack trace if failed */
+    stack?: string;
+    /** Duration of the action */
+    durationMs: number;
+    /** Timestamp when completed */
+    timestamp: number;
+    /** Request ID if provided */
+    requestId?: string;
+}
+/**
+ * Workflow run request
+ */
+interface WorkflowRunRequest {
+    /** Parameters for the workflow */
+    params?: Record<string, unknown>;
+    /** Request ID for tracking */
+    requestId?: string;
+    /** Start from a specific step */
+    startStep?: string;
+    /** Stop at a specific step */
+    stopStep?: string;
+    /** Step timeout */
+    stepTimeout?: number;
+    /** Total workflow timeout */
+    workflowTimeout?: number;
+}
+/**
+ * Workflow step result
+ */
+interface WorkflowStepResult {
+    /** Step ID */
+    stepId: string;
+    /** Step type */
+    stepType: string;
+    /** Whether the step succeeded */
+    success: boolean;
+    /** Step result */
+    result?: unknown;
+    /** Error if failed */
+    error?: string;
+    /** Duration in milliseconds */
+    durationMs: number;
+    /** Timestamp when completed */
+    timestamp: number;
+}
+/**
+ * Workflow run status
+ */
+type WorkflowRunStatus = 'pending' | 'running' | 'completed' | 'failed' | 'cancelled';
+/**
+ * Workflow run response
+ */
+interface WorkflowRunResponse {
+    /** Workflow ID */
+    workflowId: string;
+    /** Run ID for tracking */
+    runId: string;
+    /** Current status */
+    status: WorkflowRunStatus;
+    /** Step results */
+    steps: WorkflowStepResult[];
+    /** Current step index */
+    currentStep?: number;
+    /** Total steps */
+    totalSteps: number;
+    /** Overall success */
+    success?: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Start timestamp */
+    startedAt: number;
+    /** End timestamp */
+    completedAt?: number;
+    /** Total duration */
+    durationMs?: number;
+}
+/**
+ * Element info for discovery
+ */
+interface DiscoveredElement {
+    /** Element ID */
+    id: string;
+    /** Element type */
+    type: string;
+    /** Human-readable label */
+    label?: string;
+    /** Tag name */
+    tagName: string;
+    /** Role attribute */
+    role?: string;
+    /** Accessible name */
+    accessibleName?: string;
+    /** Available actions */
+    actions: string[];
+    /** Current state */
+    state: ElementState;
+    /** Whether registered with UI Bridge */
+    registered: boolean;
+}
+/**
+ * Find request options
+ *
+ * Used to find/discover controllable elements in the UI.
+ */
+interface FindRequest {
+    /** Root element selector to start from */
+    root?: string;
+    /** Only find interactive elements */
+    interactiveOnly?: boolean;
+    /** Include hidden elements */
+    includeHidden?: boolean;
+    /** Maximum elements to return */
+    limit?: number;
+    /** Filter by element type */
+    types?: string[];
+    /** Filter by selector */
+    selector?: string;
+}
+/**
+ * Find response
+ *
+ * Response from finding/discovering controllable elements.
+ */
+interface FindResponse {
+    /** Found elements */
+    elements: DiscoveredElement[];
+    /** Total elements found */
+    total: number;
+    /** Find duration */
+    durationMs: number;
+    /** Timestamp */
+    timestamp: number;
+}
+/**
+ * @deprecated Use FindRequest instead
+ */
+type DiscoveryRequest = FindRequest;
+/**
+ * @deprecated Use FindResponse instead
+ */
+type DiscoveryResponse = FindResponse;
+/**
+ * Control snapshot - full state of controllable UI
+ */
+interface ControlSnapshot {
+    /** Timestamp */
+    timestamp: number;
+    /** All registered elements */
+    elements: Array<{
+        id: string;
+        type: string;
+        label?: string;
+        actions: string[];
+        state: ElementState;
+    }>;
+    /** All registered components */
+    components: Array<{
+        id: string;
+        name: string;
+        actions: string[];
+    }>;
+    /** Available workflows */
+    workflows: Array<{
+        id: string;
+        name: string;
+        stepCount: number;
+    }>;
+    /** Active workflow runs */
+    activeRuns: Array<{
+        runId: string;
+        workflowId: string;
+        status: WorkflowRunStatus;
+        currentStep: number;
+        totalSteps: number;
+    }>;
+}
+/**
+ * Action types for keyboard input
+ */
+interface KeyboardAction {
+    /** Key to press */
+    key: string;
+    /** Key modifiers */
+    modifiers?: {
+        ctrl?: boolean;
+        shift?: boolean;
+        alt?: boolean;
+        meta?: boolean;
+    };
+    /** Hold duration for key press */
+    holdDuration?: number;
+}
+/**
+ * Action types for mouse input
+ */
+interface MouseAction {
+    /** Mouse button */
+    button?: 'left' | 'right' | 'middle';
+    /** Click count */
+    clickCount?: number;
+    /** Coordinates relative to element */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Hold duration for click */
+    holdDuration?: number;
+}
+/**
+ * Action types for scroll input
+ */
+interface ScrollAction {
+    /** Scroll direction */
+    direction?: 'up' | 'down' | 'left' | 'right';
+    /** Scroll amount in pixels */
+    amount?: number;
+    /** Scroll to specific position */
+    position?: {
+        x: number;
+        y: number;
+    };
+    /** Scroll to element */
+    toElement?: string;
+    /** Smooth scroll */
+    smooth?: boolean;
+}
+/**
+ * Type action for text input
+ */
+interface TypeAction {
+    /** Text to type */
+    text: string;
+    /** Clear existing value first */
+    clear?: boolean;
+    /** Delay between keystrokes (ms) */
+    delay?: number;
+    /** Trigger events (input, change) */
+    triggerEvents?: boolean;
+}
+/**
+ * Select action for dropdowns
+ */
+interface SelectAction {
+    /** Value(s) to select */
+    value: string | string[];
+    /** Select by label instead of value */
+    byLabel?: boolean;
+    /** For multi-select: add to selection */
+    additive?: boolean;
+}
+/**
+ * Wait condition result
+ */
+interface WaitResult {
+    /** Whether the condition was met */
+    met: boolean;
+    /** Time waited in milliseconds */
+    waitedMs: number;
+    /** Final state when resolved */
+    state?: ElementState;
+    /** Error if timed out */
+    error?: string;
+}
+/**
+ * Action executor interface
+ */
+interface ActionExecutor {
+    /** Execute an action on an element */
+    executeAction(elementId: string, action: ControlActionRequest): Promise<ControlActionResponse>;
+    /** Execute an action on a component */
+    executeComponentAction(componentId: string, action: ComponentActionRequest): Promise<ComponentActionResponse>;
+    /** Wait for a condition */
+    waitFor(elementId: string, options: WaitOptions): Promise<WaitResult>;
+    /** Find controllable elements */
+    find(options?: FindRequest): Promise<FindResponse>;
+    /**
+     * @deprecated Use find() instead
+     */
+    discover(options?: FindRequest): Promise<FindResponse>;
+    /** Get control snapshot */
+    getSnapshot(): Promise<ControlSnapshot>;
+}
+/**
+ * Workflow engine interface
+ */
+interface WorkflowEngine {
+    /** Run a workflow */
+    run(workflowId: string, request?: WorkflowRunRequest): Promise<WorkflowRunResponse>;
+    /** Get workflow run status */
+    getRunStatus(runId: string): Promise<WorkflowRunResponse | null>;
+    /** Cancel a running workflow */
+    cancel(runId: string): Promise<boolean>;
+    /** List active runs */
+    listActiveRuns(): Promise<WorkflowRunResponse[]>;
+}
+
+export type { ActionExecutor as A, ComponentActionRequest as C, DiscoveredElement as D, FindRequest as F, KeyboardAction as K, MouseAction as M, ScrollAction as S, TypeAction as T, WaitResult as W, ComponentActionResponse as a, ControlActionRequest as b, ControlActionResponse as c, ControlSnapshot as d, DiscoveryRequest as e, DiscoveryResponse as f, FindResponse as g, SelectAction as h, WorkflowEngine as i, WorkflowRunRequest as j, WorkflowRunResponse as k, WorkflowRunStatus as l, WorkflowStepResult as m };

package/dist/websocket-client-B2LC9CYc.d.mts

@@ -0,0 +1,124 @@
+import { W as WSClientConfig, t as WSConnectionState, X as WSSubscriptionOptions, e as BridgeEventType, f as BridgeSnapshot, a as ActionRequest, b as ActionResponse, c as BridgeEvent } from './types-BpvpStn3.mjs';
+
+/**
+ * WebSocket Client for UI Bridge
+ *
+ * Provides real-time communication with UI Bridge server.
+ */
+
+/**
+ * WebSocket client for UI Bridge
+ */
+declare class UIBridgeWSClient {
+    private ws;
+    private config;
+    private state;
+    private clientId;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private pingTimer;
+    private pendingRequests;
+    private connectionListeners;
+    private eventListeners;
+    private errorListeners;
+    private subscriptions;
+    constructor(config: WSClientConfig);
+    /**
+     * Get current connection state
+     */
+    get connectionState(): WSConnectionState;
+    /**
+     * Get assigned client ID
+     */
+    get id(): string | null;
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to events
+     */
+    subscribe(options: WSSubscriptionOptions): Promise<BridgeEventType[]>;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribe(events?: BridgeEventType[]): Promise<BridgeEventType[]>;
+    /**
+     * Find elements
+     */
+    find(options?: {
+        interactiveOnly?: boolean;
+        includeState?: boolean;
+        selector?: string;
+    }): Promise<BridgeSnapshot['elements']>;
+    /**
+     * Discover elements
+     * @deprecated Use find() instead
+     */
+    discover(options?: {
+        interactiveOnly?: boolean;
+        includeState?: boolean;
+        selector?: string;
+    }): Promise<BridgeSnapshot['elements']>;
+    /**
+     * Get element details
+     */
+    getElement(elementId: string, includeState?: boolean): Promise<BridgeSnapshot['elements'][0] | null>;
+    /**
+     * Get full snapshot
+     */
+    getSnapshot(): Promise<BridgeSnapshot>;
+    /**
+     * Execute action on an element
+     */
+    executeAction(elementId: string, action: ActionRequest): Promise<ActionResponse>;
+    /**
+     * Execute component action
+     */
+    executeComponentAction(componentId: string, action: string, params?: Record<string, unknown>): Promise<ActionResponse>;
+    /**
+     * Execute workflow with optional progress streaming
+     */
+    executeWorkflow(workflowId: string, params?: Record<string, unknown>, onProgress?: (progress: {
+        currentStep: number;
+        totalSteps: number;
+        step: {
+            id: string;
+            status: string;
+        };
+    }) => void): Promise<{
+        success: boolean;
+        results: unknown[];
+    }>;
+    /**
+     * Add connection state listener
+     */
+    onConnectionChange(listener: (state: WSConnectionState) => void): () => void;
+    /**
+     * Add event listener
+     */
+    onEvent(eventType: BridgeEventType | '*', listener: (event: BridgeEvent) => void): () => void;
+    /**
+     * Add error listener
+     */
+    onError(listener: (error: Error) => void): () => void;
+    private setState;
+    private handleMessage;
+    private handleResponse;
+    private notifyEvent;
+    private notifyError;
+    private sendRequest;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+/**
+ * Create a WebSocket client instance
+ */
+declare function createWSClient(config: WSClientConfig): UIBridgeWSClient;
+
+export { UIBridgeWSClient as U, createWSClient as c };

package/dist/websocket-client-DupH0X7B.d.ts

@@ -0,0 +1,124 @@
+import { W as WSClientConfig, t as WSConnectionState, X as WSSubscriptionOptions, e as BridgeEventType, f as BridgeSnapshot, a as ActionRequest, b as ActionResponse, c as BridgeEvent } from './types-BpvpStn3.js';
+
+/**
+ * WebSocket Client for UI Bridge
+ *
+ * Provides real-time communication with UI Bridge server.
+ */
+
+/**
+ * WebSocket client for UI Bridge
+ */
+declare class UIBridgeWSClient {
+    private ws;
+    private config;
+    private state;
+    private clientId;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private pingTimer;
+    private pendingRequests;
+    private connectionListeners;
+    private eventListeners;
+    private errorListeners;
+    private subscriptions;
+    constructor(config: WSClientConfig);
+    /**
+     * Get current connection state
+     */
+    get connectionState(): WSConnectionState;
+    /**
+     * Get assigned client ID
+     */
+    get id(): string | null;
+    /**
+     * Connect to the WebSocket server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the server
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to events
+     */
+    subscribe(options: WSSubscriptionOptions): Promise<BridgeEventType[]>;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribe(events?: BridgeEventType[]): Promise<BridgeEventType[]>;
+    /**
+     * Find elements
+     */
+    find(options?: {
+        interactiveOnly?: boolean;
+        includeState?: boolean;
+        selector?: string;
+    }): Promise<BridgeSnapshot['elements']>;
+    /**
+     * Discover elements
+     * @deprecated Use find() instead
+     */
+    discover(options?: {
+        interactiveOnly?: boolean;
+        includeState?: boolean;
+        selector?: string;
+    }): Promise<BridgeSnapshot['elements']>;
+    /**
+     * Get element details
+     */
+    getElement(elementId: string, includeState?: boolean): Promise<BridgeSnapshot['elements'][0] | null>;
+    /**
+     * Get full snapshot
+     */
+    getSnapshot(): Promise<BridgeSnapshot>;
+    /**
+     * Execute action on an element
+     */
+    executeAction(elementId: string, action: ActionRequest): Promise<ActionResponse>;
+    /**
+     * Execute component action
+     */
+    executeComponentAction(componentId: string, action: string, params?: Record<string, unknown>): Promise<ActionResponse>;
+    /**
+     * Execute workflow with optional progress streaming
+     */
+    executeWorkflow(workflowId: string, params?: Record<string, unknown>, onProgress?: (progress: {
+        currentStep: number;
+        totalSteps: number;
+        step: {
+            id: string;
+            status: string;
+        };
+    }) => void): Promise<{
+        success: boolean;
+        results: unknown[];
+    }>;
+    /**
+     * Add connection state listener
+     */
+    onConnectionChange(listener: (state: WSConnectionState) => void): () => void;
+    /**
+     * Add event listener
+     */
+    onEvent(eventType: BridgeEventType | '*', listener: (event: BridgeEvent) => void): () => void;
+    /**
+     * Add error listener
+     */
+    onError(listener: (error: Error) => void): () => void;
+    private setState;
+    private handleMessage;
+    private handleResponse;
+    private notifyEvent;
+    private notifyError;
+    private sendRequest;
+    private scheduleReconnect;
+    private startPingInterval;
+    private stopPingInterval;
+}
+/**
+ * Create a WebSocket client instance
+ */
+declare function createWSClient(config: WSClientConfig): UIBridgeWSClient;
+
+export { UIBridgeWSClient as U, createWSClient as c };

package/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "@qontinui/ui-bridge",
+  "version": "0.1.1",
+  "description": "UI Bridge Framework - React hooks and providers for UI observation, control, and debugging",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./core": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.mjs",
+      "require": "./dist/core/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.mjs",
+      "require": "./dist/react/index.js"
+    },
+    "./control": {
+      "types": "./dist/control/index.d.ts",
+      "import": "./dist/control/index.mjs",
+      "require": "./dist/control/index.js"
+    },
+    "./render-log": {
+      "types": "./dist/render-log/index.d.ts",
+      "import": "./dist/render-log/index.mjs",
+      "require": "./dist/render-log/index.js"
+    },
+    "./debug": {
+      "types": "./dist/debug/index.d.ts",
+      "import": "./dist/debug/index.mjs",
+      "require": "./dist/debug/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.tsx",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@testing-library/react": "^14.1.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "jsdom": "^23.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^1.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/qontinui/ui-bridge.git",
+    "directory": "packages/ui-bridge"
+  },
+  "keywords": [
+    "react",
+    "ui",
+    "automation",
+    "testing",
+    "ai",
+    "debugging",
+    "hooks"
+  ]
+}