@cmdop/react 0.1.1

package/dist/index.js

@@ -0,0 +1,732 @@
+"use client";
+
+// src/index.tsx
+import {
+  DEFAULT_CONFIG,
+  VERSION,
+  CMDOPError,
+  ConnectionError,
+  AuthenticationError,
+  SessionError,
+  TimeoutError,
+  NotFoundError,
+  PermissionError,
+  ResourceExhaustedError,
+  CancelledError,
+  UnavailableError,
+  api,
+  machines,
+  workspaces,
+  system,
+  API_BASE_URL,
+  MachinesModule,
+  WorkspacesModule,
+  SystemModule
+} from "@cmdop/core";
+
+// src/centrifugo/client.ts
+import { Centrifuge } from "centrifuge";
+var CMDOPWebSocketClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  centrifuge = null;
+  subscriptions = /* @__PURE__ */ new Map();
+  stateListeners = /* @__PURE__ */ new Set();
+  state = {
+    isConnected: false,
+    isConnecting: false,
+    error: null
+  };
+  /**
+   * Connect to Centrifugo server
+   */
+  async connect() {
+    if (this.centrifuge) {
+      return;
+    }
+    this.updateState({ isConnecting: true, error: null });
+    try {
+      const token = await this.config.getToken();
+      this.centrifuge = new Centrifuge(this.config.url, {
+        token,
+        getToken: async () => {
+          return this.config.getToken();
+        },
+        debug: this.config.debug ?? false
+      });
+      this.centrifuge.on("connected", () => {
+        this.updateState({ isConnected: true, isConnecting: false, error: null });
+      });
+      this.centrifuge.on("disconnected", () => {
+        this.updateState({ isConnected: false, isConnecting: false });
+      });
+      this.centrifuge.on("error", (ctx) => {
+        this.updateState({ error: new Error(ctx.error?.message ?? "Connection error") });
+      });
+      this.centrifuge.connect();
+    } catch (error) {
+      this.updateState({
+        isConnecting: false,
+        error: error instanceof Error ? error : new Error(String(error))
+      });
+      throw error;
+    }
+  }
+  /**
+   * Disconnect from server
+   */
+  disconnect() {
+    if (this.centrifuge) {
+      this.subscriptions.forEach((sub) => sub.unsubscribe());
+      this.subscriptions.clear();
+      this.centrifuge.disconnect();
+      this.centrifuge = null;
+      this.updateState({ isConnected: false, isConnecting: false });
+    }
+  }
+  /**
+   * Subscribe to a channel
+   */
+  subscribe(channel, onPublication, onError) {
+    if (!this.centrifuge) {
+      throw new Error("Not connected");
+    }
+    if (this.subscriptions.has(channel)) {
+      const existing = this.subscriptions.get(channel);
+      existing.on("publication", (ctx) => {
+        onPublication(ctx.data);
+      });
+      return () => this.unsubscribe(channel);
+    }
+    const subscription = this.centrifuge.newSubscription(channel);
+    subscription.on("publication", (ctx) => {
+      onPublication(ctx.data);
+    });
+    subscription.on("error", (ctx) => {
+      onError?.(new Error(ctx.error?.message ?? "Subscription error"));
+    });
+    subscription.subscribe();
+    this.subscriptions.set(channel, subscription);
+    return () => this.unsubscribe(channel);
+  }
+  /**
+   * Unsubscribe from a channel
+   */
+  unsubscribe(channel) {
+    const subscription = this.subscriptions.get(channel);
+    if (subscription) {
+      subscription.unsubscribe();
+      this.subscriptions.delete(channel);
+    }
+  }
+  /**
+   * Make an RPC call via Centrifugo
+   */
+  async rpc(method, data) {
+    if (!this.centrifuge) {
+      throw new Error("Not connected");
+    }
+    const result = await this.centrifuge.rpc(method, data);
+    return result.data;
+  }
+  /**
+   * Publish to a channel (fire-and-forget)
+   */
+  async publish(channel, data) {
+    if (!this.centrifuge) {
+      throw new Error("Not connected");
+    }
+    const subscription = this.subscriptions.get(channel);
+    if (subscription) {
+      await subscription.publish(data);
+    }
+  }
+  /**
+   * Get current connection state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Add state change listener
+   */
+  onStateChange(listener) {
+    this.stateListeners.add(listener);
+    return () => this.stateListeners.delete(listener);
+  }
+  updateState(partial) {
+    this.state = { ...this.state, ...partial };
+    this.stateListeners.forEach((listener) => listener(this.state));
+  }
+};
+
+// src/centrifugo/provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useState,
+  useCallback,
+  useRef
+} from "react";
+import { jsx } from "react/jsx-runtime";
+var WebSocketContext = createContext(null);
+function WebSocketProvider({
+  children,
+  url,
+  getToken,
+  autoConnect = true,
+  debug = false
+}) {
+  const clientRef = useRef(null);
+  const [state, setState] = useState({
+    isConnected: false,
+    isConnecting: false,
+    error: null
+  });
+  useEffect(() => {
+    const client = new CMDOPWebSocketClient({
+      url,
+      getToken,
+      debug
+    });
+    clientRef.current = client;
+    const unsubscribe = client.onStateChange(setState);
+    if (autoConnect) {
+      client.connect().catch((error) => {
+        console.error("[CMDOP WebSocket] Auto-connect failed:", error);
+      });
+    }
+    return () => {
+      unsubscribe();
+      client.disconnect();
+      clientRef.current = null;
+    };
+  }, [url, getToken, autoConnect, debug]);
+  const connect = useCallback(async () => {
+    if (clientRef.current) {
+      await clientRef.current.connect();
+    }
+  }, []);
+  const disconnect = useCallback(() => {
+    if (clientRef.current) {
+      clientRef.current.disconnect();
+    }
+  }, []);
+  const value = {
+    client: clientRef.current,
+    isConnected: state.isConnected,
+    isConnecting: state.isConnecting,
+    error: state.error,
+    connect,
+    disconnect
+  };
+  return /* @__PURE__ */ jsx(WebSocketContext.Provider, { value, children });
+}
+function useWebSocket() {
+  const context = useContext(WebSocketContext);
+  if (!context) {
+    throw new Error("useWebSocket must be used within a WebSocketProvider");
+  }
+  return context;
+}
+
+// src/centrifugo/hooks.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2, useRef as useRef2 } from "react";
+function useSubscription(options) {
+  const { channel, enabled = true, onData, onError } = options;
+  const { client, isConnected } = useWebSocket();
+  const [data, setData] = useState2(null);
+  const [error, setError] = useState2(null);
+  const [isSubscribed, setIsSubscribed] = useState2(false);
+  const onDataRef = useRef2(onData);
+  const onErrorRef = useRef2(onError);
+  onDataRef.current = onData;
+  onErrorRef.current = onError;
+  useEffect2(() => {
+    if (!client || !isConnected || !enabled || !channel) {
+      setIsSubscribed(false);
+      return;
+    }
+    const handleData = (received) => {
+      setData(received);
+      onDataRef.current?.(received);
+    };
+    const handleError = (err) => {
+      setError(err);
+      onErrorRef.current?.(err);
+    };
+    try {
+      const unsubscribe = client.subscribe(channel, handleData, handleError);
+      setIsSubscribed(true);
+      setError(null);
+      return () => {
+        unsubscribe();
+        setIsSubscribed(false);
+      };
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      onErrorRef.current?.(error2);
+    }
+  }, [client, isConnected, enabled, channel]);
+  return { data, error, isSubscribed };
+}
+function useRPC(options = {}) {
+  const { onError } = options;
+  const { client, isConnected } = useWebSocket();
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const onErrorRef = useRef2(onError);
+  onErrorRef.current = onError;
+  const call = useCallback2(
+    async (method, data) => {
+      if (!client || !isConnected) {
+        const err = new Error("WebSocket not connected");
+        setError(err);
+        onErrorRef.current?.(err);
+        throw err;
+      }
+      setIsLoading(true);
+      setError(null);
+      try {
+        const result = await client.rpc(method, data);
+        return result;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        onErrorRef.current?.(error2);
+        throw error2;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client, isConnected]
+  );
+  const reset = useCallback2(() => {
+    setError(null);
+  }, []);
+  return { call, isLoading, error, reset };
+}
+
+// src/hooks/useTerminal.ts
+import { useState as useState3, useCallback as useCallback3, useRef as useRef3 } from "react";
+function useTerminal(options) {
+  const { sessionId, enabled = true, onOutput, onStatus, onError } = options;
+  const [output, setOutput] = useState3("");
+  const [status, setStatus] = useState3(null);
+  const [error, setError] = useState3(null);
+  const [isConnecting, setIsConnecting] = useState3(false);
+  const onOutputRef = useRef3(onOutput);
+  const onStatusRef = useRef3(onStatus);
+  const onErrorRef = useRef3(onError);
+  onOutputRef.current = onOutput;
+  onStatusRef.current = onStatus;
+  onErrorRef.current = onError;
+  const { call, isLoading: isRpcLoading } = useRPC({
+    onError: (err) => {
+      setError(err);
+      onErrorRef.current?.(err);
+    }
+  });
+  const { isSubscribed: isOutputSubscribed } = useSubscription({
+    channel: `terminal#${sessionId}#output`,
+    enabled: enabled && !!sessionId,
+    onData: (data) => {
+      const text = data.data;
+      setOutput((prev) => prev + text);
+      onOutputRef.current?.(text);
+    },
+    onError: (err) => {
+      setError(err);
+      onErrorRef.current?.(err);
+    }
+  });
+  const { isSubscribed: isStatusSubscribed } = useSubscription({
+    channel: `terminal#${sessionId}#status`,
+    enabled: enabled && !!sessionId,
+    onData: (newStatus) => {
+      setStatus(newStatus);
+      onStatusRef.current?.(newStatus);
+    },
+    onError: (err) => {
+      setError(err);
+      onErrorRef.current?.(err);
+    }
+  });
+  const isConnected = isOutputSubscribed && isStatusSubscribed;
+  const sendInput = useCallback3(
+    async (data) => {
+      if (!sessionId) return;
+      await call("terminal.input", {
+        session_id: sessionId,
+        data
+      });
+    },
+    [call, sessionId]
+  );
+  const resize = useCallback3(
+    async (cols, rows) => {
+      if (!sessionId) return;
+      await call("terminal.resize", {
+        session_id: sessionId,
+        cols,
+        rows
+      });
+    },
+    [call, sessionId]
+  );
+  const signal = useCallback3(
+    async (sig) => {
+      if (!sessionId) return;
+      const signalNum = typeof sig === "string" ? signalNameToNumber(sig) : sig;
+      await call("terminal.signal", {
+        session_id: sessionId,
+        signal: signalNum
+      });
+    },
+    [call, sessionId]
+  );
+  const clear = useCallback3(() => {
+    setOutput("");
+  }, []);
+  return {
+    isConnected,
+    isConnecting: isConnecting || isRpcLoading,
+    error,
+    output,
+    status,
+    sendInput,
+    resize,
+    signal,
+    clear
+  };
+}
+var SIGNAL_MAP = {
+  SIGHUP: 1,
+  SIGINT: 2,
+  SIGQUIT: 3,
+  SIGKILL: 9,
+  SIGTERM: 15,
+  SIGSTOP: 19,
+  SIGCONT: 18
+};
+function signalNameToNumber(name) {
+  const upper = name.toUpperCase();
+  return SIGNAL_MAP[upper] ?? parseInt(name, 10) ?? 15;
+}
+
+// src/hooks/useAgent.ts
+import { useState as useState4, useCallback as useCallback4, useRef as useRef4 } from "react";
+function useAgent(options) {
+  const { sessionId, enabled = true, onToken, onToolCall, onToolResult, onDone, onError } = options;
+  const [isRunning, setIsRunning] = useState4(false);
+  const [streamingText, setStreamingText] = useState4("");
+  const [result, setResult] = useState4(null);
+  const [toolCalls, setToolCalls] = useState4([]);
+  const [error, setError] = useState4(null);
+  const [requestId, setRequestId] = useState4(null);
+  const onTokenRef = useRef4(onToken);
+  const onToolCallRef = useRef4(onToolCall);
+  const onToolResultRef = useRef4(onToolResult);
+  const onDoneRef = useRef4(onDone);
+  const onErrorRef = useRef4(onError);
+  onTokenRef.current = onToken;
+  onToolCallRef.current = onToolCall;
+  onToolResultRef.current = onToolResult;
+  onDoneRef.current = onDone;
+  onErrorRef.current = onError;
+  const { call } = useRPC({
+    onError: (err) => {
+      setError(err);
+      setIsRunning(false);
+      onErrorRef.current?.(err);
+    }
+  });
+  useSubscription({
+    channel: requestId ? `agent#${requestId}#events` : "",
+    enabled: enabled && !!requestId && isRunning,
+    onData: (event) => {
+      switch (event.type) {
+        case "token": {
+          const tokenData = event.data;
+          setStreamingText((prev) => prev + tokenData.text);
+          onTokenRef.current?.(tokenData.text);
+          break;
+        }
+        case "tool_call": {
+          const toolCallData = event.data;
+          setToolCalls((prev) => [...prev, toolCallData]);
+          onToolCallRef.current?.(toolCallData);
+          break;
+        }
+        case "tool_result": {
+          const toolResultData = event.data;
+          setToolCalls((prev) => prev.filter((tc) => tc.id !== toolResultData.id));
+          onToolResultRef.current?.(toolResultData);
+          break;
+        }
+        case "done": {
+          const doneData = event.data;
+          setResult(doneData.text);
+          setIsRunning(false);
+          setRequestId(null);
+          onDoneRef.current?.(doneData);
+          break;
+        }
+        case "error": {
+          const errorData = event.data;
+          const err = new Error(errorData.message);
+          setError(err);
+          setIsRunning(false);
+          setRequestId(null);
+          onErrorRef.current?.(err);
+          break;
+        }
+      }
+    },
+    onError: (err) => {
+      setError(err);
+      setIsRunning(false);
+      onErrorRef.current?.(err);
+    }
+  });
+  const run = useCallback4(
+    async (prompt, runOptions) => {
+      if (!sessionId) {
+        throw new Error("Session ID required");
+      }
+      setStreamingText("");
+      setResult(null);
+      setToolCalls([]);
+      setError(null);
+      setIsRunning(true);
+      try {
+        const response = await call("agent.run", {
+          session_id: sessionId,
+          prompt,
+          mode: runOptions?.mode,
+          timeout_seconds: runOptions?.timeoutSeconds,
+          output_schema: runOptions?.outputSchema
+        });
+        setRequestId(response.request_id);
+        if (response.text) {
+          setResult(response.text);
+          setIsRunning(false);
+          return response.text;
+        }
+        return new Promise((resolve, reject) => {
+          const checkDone = setInterval(() => {
+            if (result) {
+              clearInterval(checkDone);
+              resolve(result);
+            }
+            if (error) {
+              clearInterval(checkDone);
+              reject(error);
+            }
+          }, 100);
+          setTimeout(() => {
+            clearInterval(checkDone);
+            if (!result && !error) {
+              const timeoutError = new Error("Agent timeout");
+              setError(timeoutError);
+              setIsRunning(false);
+              reject(timeoutError);
+            }
+          }, 3e5);
+        });
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setError(error2);
+        setIsRunning(false);
+        throw error2;
+      }
+    },
+    [call, sessionId, result, error]
+  );
+  const cancel = useCallback4(async () => {
+    if (!requestId) return;
+    try {
+      await call("agent.cancel", { request_id: requestId });
+    } finally {
+      setIsRunning(false);
+      setRequestId(null);
+    }
+  }, [call, requestId]);
+  const reset = useCallback4(() => {
+    setStreamingText("");
+    setResult(null);
+    setToolCalls([]);
+    setError(null);
+    setIsRunning(false);
+    setRequestId(null);
+  }, []);
+  return {
+    run,
+    isRunning,
+    streamingText,
+    result,
+    toolCalls,
+    error,
+    reset,
+    cancel
+  };
+}
+
+// src/index.tsx
+import { createContext as createContext2, useContext as useContext2, useMemo } from "react";
+import { useState as useState5, useCallback as useCallback5 } from "react";
+import { machines as machines2, workspaces as workspaces2 } from "@cmdop/core";
+import useSWR from "swr";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var CMDOPContext = createContext2(null);
+function CMDOPProvider({ children, apiKey, token }) {
+  const [currentToken, setCurrentToken] = useState5(token);
+  const setToken = useCallback5((newToken) => {
+    setCurrentToken(newToken);
+    machines2.setToken(newToken);
+    workspaces2.setToken(newToken);
+  }, []);
+  useMemo(() => {
+    if (currentToken) {
+      machines2.setToken(currentToken);
+      workspaces2.setToken(currentToken);
+    }
+  }, [currentToken]);
+  const value = useMemo(
+    () => ({
+      config: { apiKey },
+      isAuthenticated: !!currentToken,
+      setToken
+    }),
+    [apiKey, currentToken, setToken]
+  );
+  return /* @__PURE__ */ jsx2(CMDOPContext.Provider, { value, children });
+}
+function useCMDOP() {
+  const context = useContext2(CMDOPContext);
+  if (!context) {
+    throw new Error("useCMDOP must be used within a CMDOPProvider");
+  }
+  return context;
+}
+function useMachines(options = {}) {
+  const { page, pageSize, ...swrConfig } = options;
+  const { data, error, isLoading, isValidating, mutate } = useSWR(
+    ["machines", page, pageSize],
+    async () => {
+      const response = await machines2.machines_machines.machinesList({
+        page,
+        page_size: pageSize
+      });
+      return response;
+    },
+    {
+      revalidateOnFocus: false,
+      ...swrConfig
+    }
+  );
+  return {
+    machines: data?.results ?? [],
+    total: data?.count ?? 0,
+    isLoading,
+    isValidating,
+    error,
+    refetch: () => mutate()
+  };
+}
+function useMachine(machineId, options = {}) {
+  const { data, error, isLoading, mutate } = useSWR(
+    machineId ? ["machine", machineId] : null,
+    async () => {
+      if (!machineId) return null;
+      return machines2.machines_machines.machinesRetrieve(machineId);
+    },
+    {
+      revalidateOnFocus: false,
+      ...options
+    }
+  );
+  return {
+    machine: data ?? null,
+    isLoading,
+    error,
+    refetch: () => mutate()
+  };
+}
+function useWorkspaces(options = {}) {
+  const { data, error, isLoading, isValidating, mutate } = useSWR(
+    "workspaces",
+    async () => {
+      return workspaces2.workspaces_workspaces.workspacesList();
+    },
+    {
+      revalidateOnFocus: false,
+      ...options
+    }
+  );
+  return {
+    workspaces: data?.results ?? [],
+    total: data?.count ?? 0,
+    isLoading,
+    isValidating,
+    error,
+    refetch: () => mutate()
+  };
+}
+function useWorkspace(workspaceId, options = {}) {
+  const { data, error, isLoading, mutate } = useSWR(
+    workspaceId ? ["workspace", workspaceId] : null,
+    async () => {
+      if (!workspaceId) return null;
+      return workspaces2.workspaces_workspaces.workspacesRetrieve(workspaceId);
+    },
+    {
+      revalidateOnFocus: false,
+      ...options
+    }
+  );
+  return {
+    workspace: data ?? null,
+    isLoading,
+    error,
+    refetch: () => mutate()
+  };
+}
+export {
+  API_BASE_URL,
+  AuthenticationError,
+  CMDOPError,
+  CMDOPProvider,
+  CMDOPWebSocketClient,
+  CancelledError,
+  ConnectionError,
+  DEFAULT_CONFIG,
+  MachinesModule,
+  NotFoundError,
+  PermissionError,
+  ResourceExhaustedError,
+  SessionError,
+  SystemModule,
+  TimeoutError,
+  UnavailableError,
+  VERSION,
+  WebSocketProvider,
+  WorkspacesModule,
+  api,
+  machines,
+  system,
+  useAgent,
+  useCMDOP,
+  useMachine,
+  useMachines,
+  useRPC,
+  useSubscription,
+  useTerminal,
+  useWebSocket,
+  useWorkspace,
+  useWorkspaces,
+  workspaces
+};