@cmdop/react 0.1.1

package/dist/index.cjs

@@ -0,0 +1,770 @@
+"use strict";
+"use client";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  API_BASE_URL: () => import_core.API_BASE_URL,
+  AuthenticationError: () => import_core.AuthenticationError,
+  CMDOPError: () => import_core.CMDOPError,
+  CMDOPProvider: () => CMDOPProvider,
+  CMDOPWebSocketClient: () => CMDOPWebSocketClient,
+  CancelledError: () => import_core.CancelledError,
+  ConnectionError: () => import_core.ConnectionError,
+  DEFAULT_CONFIG: () => import_core.DEFAULT_CONFIG,
+  MachinesModule: () => import_core.MachinesModule,
+  NotFoundError: () => import_core.NotFoundError,
+  PermissionError: () => import_core.PermissionError,
+  ResourceExhaustedError: () => import_core.ResourceExhaustedError,
+  SessionError: () => import_core.SessionError,
+  SystemModule: () => import_core.SystemModule,
+  TimeoutError: () => import_core.TimeoutError,
+  UnavailableError: () => import_core.UnavailableError,
+  VERSION: () => import_core.VERSION,
+  WebSocketProvider: () => WebSocketProvider,
+  WorkspacesModule: () => import_core.WorkspacesModule,
+  api: () => import_core.api,
+  machines: () => import_core.machines,
+  system: () => import_core.system,
+  useAgent: () => useAgent,
+  useCMDOP: () => useCMDOP,
+  useMachine: () => useMachine,
+  useMachines: () => useMachines,
+  useRPC: () => useRPC,
+  useSubscription: () => useSubscription,
+  useTerminal: () => useTerminal,
+  useWebSocket: () => useWebSocket,
+  useWorkspace: () => useWorkspace,
+  useWorkspaces: () => useWorkspaces,
+  workspaces: () => import_core.workspaces
+});
+module.exports = __toCommonJS(index_exports);
+var import_core = require("@cmdop/core");
+
+// src/centrifugo/client.ts
+var import_centrifuge = require("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 import_centrifuge.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
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var WebSocketContext = (0, import_react.createContext)(null);
+function WebSocketProvider({
+  children,
+  url,
+  getToken,
+  autoConnect = true,
+  debug = false
+}) {
+  const clientRef = (0, import_react.useRef)(null);
+  const [state, setState] = (0, import_react.useState)({
+    isConnected: false,
+    isConnecting: false,
+    error: null
+  });
+  (0, import_react.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 = (0, import_react.useCallback)(async () => {
+    if (clientRef.current) {
+      await clientRef.current.connect();
+    }
+  }, []);
+  const disconnect = (0, import_react.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__ */ (0, import_jsx_runtime.jsx)(WebSocketContext.Provider, { value, children });
+}
+function useWebSocket() {
+  const context = (0, import_react.useContext)(WebSocketContext);
+  if (!context) {
+    throw new Error("useWebSocket must be used within a WebSocketProvider");
+  }
+  return context;
+}
+
+// src/centrifugo/hooks.ts
+var import_react2 = require("react");
+function useSubscription(options) {
+  const { channel, enabled = true, onData, onError } = options;
+  const { client, isConnected } = useWebSocket();
+  const [data, setData] = (0, import_react2.useState)(null);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const [isSubscribed, setIsSubscribed] = (0, import_react2.useState)(false);
+  const onDataRef = (0, import_react2.useRef)(onData);
+  const onErrorRef = (0, import_react2.useRef)(onError);
+  onDataRef.current = onData;
+  onErrorRef.current = onError;
+  (0, import_react2.useEffect)(() => {
+    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] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const onErrorRef = (0, import_react2.useRef)(onError);
+  onErrorRef.current = onError;
+  const call = (0, import_react2.useCallback)(
+    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 = (0, import_react2.useCallback)(() => {
+    setError(null);
+  }, []);
+  return { call, isLoading, error, reset };
+}
+
+// src/hooks/useTerminal.ts
+var import_react3 = require("react");
+function useTerminal(options) {
+  const { sessionId, enabled = true, onOutput, onStatus, onError } = options;
+  const [output, setOutput] = (0, import_react3.useState)("");
+  const [status, setStatus] = (0, import_react3.useState)(null);
+  const [error, setError] = (0, import_react3.useState)(null);
+  const [isConnecting, setIsConnecting] = (0, import_react3.useState)(false);
+  const onOutputRef = (0, import_react3.useRef)(onOutput);
+  const onStatusRef = (0, import_react3.useRef)(onStatus);
+  const onErrorRef = (0, import_react3.useRef)(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 = (0, import_react3.useCallback)(
+    async (data) => {
+      if (!sessionId) return;
+      await call("terminal.input", {
+        session_id: sessionId,
+        data
+      });
+    },
+    [call, sessionId]
+  );
+  const resize = (0, import_react3.useCallback)(
+    async (cols, rows) => {
+      if (!sessionId) return;
+      await call("terminal.resize", {
+        session_id: sessionId,
+        cols,
+        rows
+      });
+    },
+    [call, sessionId]
+  );
+  const signal = (0, import_react3.useCallback)(
+    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 = (0, import_react3.useCallback)(() => {
+    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
+var import_react4 = require("react");
+function useAgent(options) {
+  const { sessionId, enabled = true, onToken, onToolCall, onToolResult, onDone, onError } = options;
+  const [isRunning, setIsRunning] = (0, import_react4.useState)(false);
+  const [streamingText, setStreamingText] = (0, import_react4.useState)("");
+  const [result, setResult] = (0, import_react4.useState)(null);
+  const [toolCalls, setToolCalls] = (0, import_react4.useState)([]);
+  const [error, setError] = (0, import_react4.useState)(null);
+  const [requestId, setRequestId] = (0, import_react4.useState)(null);
+  const onTokenRef = (0, import_react4.useRef)(onToken);
+  const onToolCallRef = (0, import_react4.useRef)(onToolCall);
+  const onToolResultRef = (0, import_react4.useRef)(onToolResult);
+  const onDoneRef = (0, import_react4.useRef)(onDone);
+  const onErrorRef = (0, import_react4.useRef)(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 = (0, import_react4.useCallback)(
+    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 = (0, import_react4.useCallback)(async () => {
+    if (!requestId) return;
+    try {
+      await call("agent.cancel", { request_id: requestId });
+    } finally {
+      setIsRunning(false);
+      setRequestId(null);
+    }
+  }, [call, requestId]);
+  const reset = (0, import_react4.useCallback)(() => {
+    setStreamingText("");
+    setResult(null);
+    setToolCalls([]);
+    setError(null);
+    setIsRunning(false);
+    setRequestId(null);
+  }, []);
+  return {
+    run,
+    isRunning,
+    streamingText,
+    result,
+    toolCalls,
+    error,
+    reset,
+    cancel
+  };
+}
+
+// src/index.tsx
+var import_react5 = require("react");
+var import_react6 = require("react");
+var import_core2 = require("@cmdop/core");
+var import_swr = __toESM(require("swr"), 1);
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var CMDOPContext = (0, import_react5.createContext)(null);
+function CMDOPProvider({ children, apiKey, token }) {
+  const [currentToken, setCurrentToken] = (0, import_react6.useState)(token);
+  const setToken = (0, import_react6.useCallback)((newToken) => {
+    setCurrentToken(newToken);
+    import_core2.machines.setToken(newToken);
+    import_core2.workspaces.setToken(newToken);
+  }, []);
+  (0, import_react5.useMemo)(() => {
+    if (currentToken) {
+      import_core2.machines.setToken(currentToken);
+      import_core2.workspaces.setToken(currentToken);
+    }
+  }, [currentToken]);
+  const value = (0, import_react5.useMemo)(
+    () => ({
+      config: { apiKey },
+      isAuthenticated: !!currentToken,
+      setToken
+    }),
+    [apiKey, currentToken, setToken]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(CMDOPContext.Provider, { value, children });
+}
+function useCMDOP() {
+  const context = (0, import_react5.useContext)(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 } = (0, import_swr.default)(
+    ["machines", page, pageSize],
+    async () => {
+      const response = await import_core2.machines.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 } = (0, import_swr.default)(
+    machineId ? ["machine", machineId] : null,
+    async () => {
+      if (!machineId) return null;
+      return import_core2.machines.machines_machines.machinesRetrieve(machineId);
+    },
+    {
+      revalidateOnFocus: false,
+      ...options
+    }
+  );
+  return {
+    machine: data ?? null,
+    isLoading,
+    error,
+    refetch: () => mutate()
+  };
+}
+function useWorkspaces(options = {}) {
+  const { data, error, isLoading, isValidating, mutate } = (0, import_swr.default)(
+    "workspaces",
+    async () => {
+      return import_core2.workspaces.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 } = (0, import_swr.default)(
+    workspaceId ? ["workspace", workspaceId] : null,
+    async () => {
+      if (!workspaceId) return null;
+      return import_core2.workspaces.workspaces_workspaces.workspacesRetrieve(workspaceId);
+    },
+    {
+      revalidateOnFocus: false,
+      ...options
+    }
+  );
+  return {
+    workspace: data ?? null,
+    isLoading,
+    error,
+    refetch: () => mutate()
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});