@cmdop/react 0.1.1

package/dist/index.d.cts

@@ -0,0 +1,538 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { CMDOPConfig } from '@cmdop/core';
+export { API_BASE_URL, AuthenticationError, CMDOPConfig, CMDOPError, CancelledError, ConnectionError, DEFAULT_CONFIG, FileInfo, MachinesModule, NotFoundError, PermissionError, ResourceExhaustedError, SessionError, SessionInfo, SessionState, SystemModule, TimeoutError, TransportMode, UnavailableError, VERSION, WorkspacesModule, api, machines, system, workspaces } from '@cmdop/core';
+import { ReactNode } from 'react';
+import { SWRConfiguration } from 'swr';
+
+/**
+ * Centrifugo WebSocket client for CMDOP
+ * Simplified implementation based on @djangocfg/centrifugo patterns
+ */
+interface CMDOPWebSocketConfig {
+    url: string;
+    getToken: () => Promise<string>;
+    timeout?: number;
+    debug?: boolean;
+}
+interface ConnectionState {
+    isConnected: boolean;
+    isConnecting: boolean;
+    error: Error | null;
+}
+type ConnectionStateListener = (state: ConnectionState) => void;
+/**
+ * CMDOP WebSocket client wrapping Centrifuge
+ */
+declare class CMDOPWebSocketClient {
+    private config;
+    private centrifuge;
+    private subscriptions;
+    private stateListeners;
+    private state;
+    constructor(config: CMDOPWebSocketConfig);
+    /**
+     * Connect to Centrifugo server
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from server
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a channel
+     */
+    subscribe<T = unknown>(channel: string, onPublication: (data: T) => void, onError?: (error: Error) => void): () => void;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribe(channel: string): void;
+    /**
+     * Make an RPC call via Centrifugo
+     */
+    rpc<TRequest, TResponse>(method: string, data: TRequest): Promise<TResponse>;
+    /**
+     * Publish to a channel (fire-and-forget)
+     */
+    publish<T>(channel: string, data: T): Promise<void>;
+    /**
+     * Get current connection state
+     */
+    getState(): ConnectionState;
+    /**
+     * Add state change listener
+     */
+    onStateChange(listener: ConnectionStateListener): () => void;
+    private updateState;
+}
+
+interface WebSocketContextValue {
+    client: CMDOPWebSocketClient | null;
+    isConnected: boolean;
+    isConnecting: boolean;
+    error: Error | null;
+    connect: () => Promise<void>;
+    disconnect: () => void;
+}
+interface WebSocketProviderProps {
+    children: ReactNode;
+    /**
+     * WebSocket URL (e.g., wss://api.cmdop.com/connection/websocket)
+     */
+    url: string;
+    /**
+     * Function to get auth token
+     */
+    getToken: () => Promise<string>;
+    /**
+     * Auto-connect on mount
+     * @default true
+     */
+    autoConnect?: boolean;
+    /**
+     * Enable debug logging
+     * @default false
+     */
+    debug?: boolean;
+}
+declare function WebSocketProvider({ children, url, getToken, autoConnect, debug, }: WebSocketProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access WebSocket context
+ */
+declare function useWebSocket(): WebSocketContextValue;
+
+/**
+ * Centrifugo React hooks for CMDOP
+ */
+interface UseSubscriptionOptions<T> {
+    /**
+     * Channel to subscribe to
+     */
+    channel: string;
+    /**
+     * Enable/disable subscription
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Callback when data is received
+     */
+    onData?: (data: T) => void;
+    /**
+     * Callback on error
+     */
+    onError?: (error: Error) => void;
+}
+interface UseSubscriptionResult<T> {
+    /**
+     * Last received data
+     */
+    data: T | null;
+    /**
+     * Subscription error
+     */
+    error: Error | null;
+    /**
+     * Whether subscribed
+     */
+    isSubscribed: boolean;
+}
+/**
+ * Subscribe to a Centrifugo channel
+ */
+declare function useSubscription<T = unknown>(options: UseSubscriptionOptions<T>): UseSubscriptionResult<T>;
+interface UseRPCOptions {
+    /**
+     * Callback on error
+     */
+    onError?: (error: Error) => void;
+}
+interface UseRPCResult {
+    /**
+     * Make an RPC call
+     */
+    call: <TRequest, TResponse>(method: string, data: TRequest) => Promise<TResponse>;
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Last error
+     */
+    error: Error | null;
+    /**
+     * Reset error state
+     */
+    reset: () => void;
+}
+/**
+ * Make RPC calls via Centrifugo
+ */
+declare function useRPC(options?: UseRPCOptions): UseRPCResult;
+
+/**
+ * useTerminal hook - Real-time terminal connection via WebSocket
+ */
+interface TerminalOutput {
+    /**
+     * Output data (may be base64 encoded)
+     */
+    data: string;
+    /**
+     * Timestamp
+     */
+    timestamp?: string;
+}
+interface TerminalStatus {
+    /**
+     * Session state
+     */
+    state: 'active' | 'closed' | 'error';
+    /**
+     * Exit code if closed
+     */
+    exitCode?: number;
+}
+interface UseTerminalOptions {
+    /**
+     * Session ID to connect to
+     */
+    sessionId: string;
+    /**
+     * Enable connection
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Callback when output is received
+     */
+    onOutput?: (data: string) => void;
+    /**
+     * Callback when status changes
+     */
+    onStatus?: (status: TerminalStatus) => void;
+    /**
+     * Callback on error
+     */
+    onError?: (error: Error) => void;
+}
+interface UseTerminalResult {
+    /**
+     * Whether connected to terminal
+     */
+    isConnected: boolean;
+    /**
+     * Whether connecting
+     */
+    isConnecting: boolean;
+    /**
+     * Connection/operation error
+     */
+    error: Error | null;
+    /**
+     * Accumulated output
+     */
+    output: string;
+    /**
+     * Current terminal status
+     */
+    status: TerminalStatus | null;
+    /**
+     * Send input to terminal
+     */
+    sendInput: (data: string) => Promise<void>;
+    /**
+     * Resize terminal
+     */
+    resize: (cols: number, rows: number) => Promise<void>;
+    /**
+     * Send signal (e.g., SIGINT)
+     */
+    signal: (sig: number | string) => Promise<void>;
+    /**
+     * Clear accumulated output
+     */
+    clear: () => void;
+}
+/**
+ * Hook for real-time terminal interaction via WebSocket
+ *
+ * @example
+ * ```tsx
+ * function Terminal({ sessionId }: { sessionId: string }) {
+ *   const {
+ *     isConnected,
+ *     output,
+ *     sendInput,
+ *     resize,
+ *   } = useTerminal({
+ *     sessionId,
+ *     onOutput: (data) => console.log('Received:', data),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <pre>{output}</pre>
+ *       <input onKeyDown={(e) => {
+ *         if (e.key === 'Enter') sendInput(e.currentTarget.value + '\n');
+ *       }} />
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useTerminal(options: UseTerminalOptions): UseTerminalResult;
+
+/**
+ * useAgent hook - AI agent execution via WebSocket
+ */
+type AgentEventType = 'token' | 'tool_call' | 'tool_result' | 'thinking' | 'error' | 'done';
+interface AgentEvent {
+    /**
+     * Event type
+     */
+    type: AgentEventType;
+    /**
+     * Event payload
+     */
+    data: unknown;
+    /**
+     * Timestamp
+     */
+    timestamp?: string;
+}
+interface AgentTokenEvent {
+    type: 'token';
+    data: {
+        text: string;
+    };
+}
+interface AgentToolCallEvent {
+    type: 'tool_call';
+    data: {
+        id: string;
+        name: string;
+        input: unknown;
+    };
+}
+interface AgentToolResultEvent {
+    type: 'tool_result';
+    data: {
+        id: string;
+        output: unknown;
+        error?: string;
+    };
+}
+interface AgentDoneEvent {
+    type: 'done';
+    data: {
+        text: string;
+        usage?: {
+            promptTokens: number;
+            completionTokens: number;
+            totalTokens: number;
+        };
+        durationMs: number;
+    };
+}
+interface AgentErrorEvent {
+    type: 'error';
+    data: {
+        message: string;
+        code?: string;
+    };
+}
+interface UseAgentOptions {
+    /**
+     * Session ID for agent context
+     */
+    sessionId: string;
+    /**
+     * Enable connection
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Callback for streaming tokens
+     */
+    onToken?: (text: string) => void;
+    /**
+     * Callback for tool calls
+     */
+    onToolCall?: (toolCall: AgentToolCallEvent['data']) => void;
+    /**
+     * Callback for tool results
+     */
+    onToolResult?: (result: AgentToolResultEvent['data']) => void;
+    /**
+     * Callback when agent completes
+     */
+    onDone?: (result: AgentDoneEvent['data']) => void;
+    /**
+     * Callback on error
+     */
+    onError?: (error: Error) => void;
+}
+interface UseAgentResult {
+    /**
+     * Run agent with prompt
+     */
+    run: (prompt: string, options?: RunAgentOptions) => Promise<string>;
+    /**
+     * Whether agent is running
+     */
+    isRunning: boolean;
+    /**
+     * Streaming text (accumulated tokens)
+     */
+    streamingText: string;
+    /**
+     * Final result text
+     */
+    result: string | null;
+    /**
+     * Current tool calls in progress
+     */
+    toolCalls: AgentToolCallEvent['data'][];
+    /**
+     * Error if any
+     */
+    error: Error | null;
+    /**
+     * Reset state
+     */
+    reset: () => void;
+    /**
+     * Cancel running agent
+     */
+    cancel: () => Promise<void>;
+}
+interface RunAgentOptions {
+    /**
+     * Agent mode
+     */
+    mode?: 'chat' | 'terminal' | 'command' | 'router' | 'planner';
+    /**
+     * Timeout in seconds
+     */
+    timeoutSeconds?: number;
+    /**
+     * JSON schema for structured output
+     */
+    outputSchema?: string;
+}
+/**
+ * Hook for AI agent execution with streaming via WebSocket
+ *
+ * @example
+ * ```tsx
+ * function AgentChat({ sessionId }: { sessionId: string }) {
+ *   const {
+ *     run,
+ *     isRunning,
+ *     streamingText,
+ *     result,
+ *   } = useAgent({
+ *     sessionId,
+ *     onToken: (text) => console.log('Token:', text),
+ *     onDone: (result) => console.log('Done:', result),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <pre>{streamingText || result}</pre>
+ *       <button onClick={() => run('Hello!')}>Send</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useAgent(options: UseAgentOptions): UseAgentResult;
+
+interface CMDOPContextValue {
+    config: CMDOPConfig;
+    isAuthenticated: boolean;
+    setToken: (token: string) => void;
+}
+interface CMDOPProviderProps {
+    children: ReactNode;
+    apiKey?: string;
+    token?: string;
+}
+/**
+ * Provider for HTTP API authentication
+ */
+declare function CMDOPProvider({ children, apiKey, token }: CMDOPProviderProps): react_jsx_runtime.JSX.Element;
+/**
+ * Hook to access HTTP API context
+ */
+declare function useCMDOP(): CMDOPContextValue;
+
+/**
+ * Machine type from API
+ */
+interface Machine {
+    id: string;
+    name: string;
+    hostname?: string;
+    status?: string;
+    workspace?: string;
+    [key: string]: unknown;
+}
+/**
+ * Workspace type from API
+ */
+interface Workspace {
+    id: string;
+    name: string;
+    [key: string]: unknown;
+}
+/**
+ * Hook for fetching machines list
+ */
+interface UseMachinesOptions extends SWRConfiguration {
+    page?: number;
+    pageSize?: number;
+}
+interface UseMachinesResult {
+    machines: Machine[];
+    total: number;
+    isLoading: boolean;
+    isValidating: boolean;
+    error: Error | undefined;
+    refetch: () => void;
+}
+declare function useMachines(options?: UseMachinesOptions): UseMachinesResult;
+/**
+ * Hook for fetching single machine
+ */
+interface UseMachineResult {
+    machine: Machine | null;
+    isLoading: boolean;
+    error: Error | undefined;
+    refetch: () => void;
+}
+declare function useMachine(machineId: string | undefined, options?: SWRConfiguration): UseMachineResult;
+/**
+ * Hook for fetching workspaces list
+ */
+interface UseWorkspacesResult {
+    workspaces: Workspace[];
+    total: number;
+    isLoading: boolean;
+    isValidating: boolean;
+    error: Error | undefined;
+    refetch: () => void;
+}
+declare function useWorkspaces(options?: SWRConfiguration): UseWorkspacesResult;
+/**
+ * Hook for fetching single workspace
+ */
+interface UseWorkspaceResult {
+    workspace: Workspace | null;
+    isLoading: boolean;
+    error: Error | undefined;
+    refetch: () => void;
+}
+declare function useWorkspace(workspaceId: string | undefined, options?: SWRConfiguration): UseWorkspaceResult;
+
+export { type AgentDoneEvent, type AgentErrorEvent, type AgentEvent, type AgentEventType, type AgentTokenEvent, type AgentToolCallEvent, type AgentToolResultEvent, CMDOPProvider, type CMDOPProviderProps, CMDOPWebSocketClient, type CMDOPWebSocketConfig, type ConnectionState, type Machine, type RunAgentOptions, type TerminalOutput, type TerminalStatus, type UseAgentOptions, type UseAgentResult, type UseMachineResult, type UseMachinesOptions, type UseMachinesResult, type UseRPCOptions, type UseRPCResult, type UseSubscriptionOptions, type UseSubscriptionResult, type UseTerminalOptions, type UseTerminalResult, type UseWorkspaceResult, type UseWorkspacesResult, WebSocketProvider, type WebSocketProviderProps, type Workspace, useAgent, useCMDOP, useMachine, useMachines, useRPC, useSubscription, useTerminal, useWebSocket, useWorkspace, useWorkspaces };