@tangle-network/sandbox-ui 0.113.6 → 0.114.0

package/dist/chunk-MYZAW4RX.js

@@ -1,665 +0,0 @@
-// src/hooks/use-pty-session.ts
-import { useState, useEffect, useRef, useCallback } from "react";
-function createEmptyBatch() {
-  return { data: "", waiters: [] };
-}
-var WS_READY_TIMEOUT_MS = 1e4;
-function toWsUrl(apiUrl, sessionId) {
-  try {
-    const base = typeof window !== "undefined" ? window.location.href : void 0;
-    const url = new URL(`${apiUrl}/terminals/${sessionId}/ws`, base);
-    if (url.protocol === "https:") url.protocol = "wss:";
-    else if (url.protocol === "http:") url.protocol = "ws:";
-    else return null;
-    return url.toString();
-  } catch {
-    return null;
-  }
-}
-var BEARER_SUBPROTOCOL_PREFIX = "bearer.";
-var TERMINAL_WS_ECHO_SUBPROTOCOL = "tangle.terminal.v1";
-function toBearerSubprotocol(token) {
-  if (typeof btoa === "undefined") return null;
-  let encoded;
-  try {
-    encoded = btoa(token);
-  } catch {
-    return null;
-  }
-  return `${BEARER_SUBPROTOCOL_PREFIX}${encoded.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "")}`;
-}
-var DEFAULT_TERMINAL_COLS = 80;
-var DEFAULT_TERMINAL_ROWS = 24;
-function createTerminalConnectionId() {
-  const cryptoApi = globalThis.crypto;
-  if (cryptoApi && typeof cryptoApi.randomUUID === "function") {
-    return `terminal-${cryptoApi.randomUUID()}`;
-  }
-  return `terminal-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
-}
-function interactiveIdentityKey(incarnationId, control) {
-  if (incarnationId === void 0 && control === void 0) return "plain";
-  if (incarnationId === void 0 || control === void 0) {
-    return `incomplete:${incarnationId ?? ""}`;
-  }
-  return [
-    incarnationId,
-    control.refDigest,
-    String(control.generation),
-    control.leaseId,
-    control.holderId,
-    control.expiresAt
-  ].join("\0");
-}
-function usePtySession({
-  apiUrl,
-  token,
-  onData,
-  connectionId: providedConnectionId,
-  incarnationId,
-  control
-}) {
-  const [isConnected, setIsConnected] = useState(false);
-  const [error, setError] = useState(null);
-  const sessionIdRef = useRef(null);
-  const connectGenRef = useRef(0);
-  const abortRef = useRef(null);
-  const retryTimerRef = useRef(void 0);
-  const retryCountRef = useRef(0);
-  const mountedRef = useRef(true);
-  const onDataRef = useRef(onData);
-  const tokenRef = useRef(token);
-  const incarnationIdRef = useRef(incarnationId);
-  const controlRef = useRef(control);
-  const exactAttachRequiredRef = useRef(
-    incarnationId !== void 0 || control !== void 0
-  );
-  const connectStreamRef = useRef(null);
-  const reconnectRef = useRef(null);
-  const shouldDeleteSessionRef = useRef(false);
-  const transportReadyRef = useRef(false);
-  const protocolFailureRef = useRef(false);
-  const colsRef = useRef(DEFAULT_TERMINAL_COLS);
-  const rowsRef = useRef(DEFAULT_TERMINAL_ROWS);
-  const wsRef = useRef(null);
-  const pendingWsRef = useRef(null);
-  const geometryPendingRef = useRef(false);
-  const pendingBatchRef = useRef(createEmptyBatch());
-  const drainPromiseRef = useRef(null);
-  const inputAbortRef = useRef(null);
-  const ensureDrainRunningRef = useRef(null);
-  const rejectPendingInput = useCallback((reason) => {
-    const batch = pendingBatchRef.current;
-    if (batch.waiters.length === 0) {
-      pendingBatchRef.current = createEmptyBatch();
-      return;
-    }
-    pendingBatchRef.current = createEmptyBatch();
-    const err = new Error(reason);
-    for (const w of batch.waiters) w.reject(err);
-  }, []);
-  const abortStream = useCallback(() => {
-    if (retryTimerRef.current) {
-      clearTimeout(retryTimerRef.current);
-      retryTimerRef.current = void 0;
-    }
-    if (abortRef.current) {
-      abortRef.current.abort();
-      abortRef.current = null;
-    }
-  }, []);
-  const closeWs = useCallback(() => {
-    const active = wsRef.current;
-    if (active) {
-      wsRef.current = null;
-      try {
-        active.close();
-      } catch {
-      }
-    }
-    const pending = pendingWsRef.current;
-    if (pending) {
-      pendingWsRef.current = null;
-      try {
-        pending.close();
-      } catch {
-      }
-    }
-  }, []);
-  const cleanup = useCallback(() => {
-    abortStream();
-    closeWs();
-    if (inputAbortRef.current) {
-      inputAbortRef.current.abort();
-      inputAbortRef.current = null;
-    }
-    transportReadyRef.current = false;
-    geometryPendingRef.current = false;
-    if (sessionIdRef.current) {
-      const sid = sessionIdRef.current;
-      const shouldDeleteSession = shouldDeleteSessionRef.current;
-      sessionIdRef.current = null;
-      shouldDeleteSessionRef.current = false;
-      if (shouldDeleteSession) {
-        fetch(`${apiUrl}/terminals/${sid}`, {
-          method: "DELETE",
-          headers: { Authorization: `Bearer ${tokenRef.current}` },
-          credentials: "include"
-        }).catch(() => {
-        });
-      }
-    }
-    rejectPendingInput("Terminal session is not connected");
-    setIsConnected(false);
-  }, [apiUrl, abortStream, closeWs, rejectPendingInput]);
-  const connectWs = useCallback((sessionId, options = {}) => {
-    return new Promise((resolve) => {
-      if (typeof WebSocket === "undefined") {
-        resolve(false);
-        return;
-      }
-      const wsUrl = toWsUrl(apiUrl, sessionId);
-      if (!wsUrl) {
-        resolve(false);
-        return;
-      }
-      const subprotocol = toBearerSubprotocol(tokenRef.current);
-      if (!subprotocol) {
-        resolve(false);
-        return;
-      }
-      let ws;
-      try {
-        ws = new WebSocket(wsUrl, [TERMINAL_WS_ECHO_SUBPROTOCOL, subprotocol]);
-      } catch {
-        resolve(false);
-        return;
-      }
-      ws.binaryType = "arraybuffer";
-      pendingWsRef.current = ws;
-      const isCurrentSocket = () => wsRef.current === ws || pendingWsRef.current === ws;
-      let opened = false;
-      let settled = false;
-      const settle = (ok) => {
-        if (settled) return;
-        settled = true;
-        clearTimeout(handshakeTimer);
-        resolve(ok);
-      };
-      const handshakeTimer = setTimeout(() => {
-        try {
-          ws.close();
-        } catch {
-        }
-        settle(false);
-      }, WS_READY_TIMEOUT_MS);
-      const failProtocol = (message) => {
-        protocolFailureRef.current = true;
-        transportReadyRef.current = false;
-        if (wsRef.current === ws) wsRef.current = null;
-        setIsConnected(false);
-        setError(message);
-        rejectPendingInput(message);
-        try {
-          ws.close();
-        } catch {
-        }
-        settle(false);
-      };
-      ws.onopen = () => {
-        opened = true;
-        if (pendingWsRef.current !== ws || !mountedRef.current) {
-          try {
-            ws.close();
-          } catch {
-          }
-          settle(false);
-          return;
-        }
-        pendingWsRef.current = null;
-        if (options.initOnOpen) {
-          try {
-            const initIncarnationId = incarnationIdRef.current;
-            const initControl = controlRef.current;
-            if (exactAttachRequiredRef.current && (!initIncarnationId || !initControl)) {
-              throw new Error(
-                "Interactive terminal identity is incomplete"
-              );
-            }
-            ws.send(JSON.stringify({
-              type: "init",
-              ...initIncarnationId !== void 0 ? { incarnationId: initIncarnationId } : {},
-              ...initControl !== void 0 ? { control: initControl } : {},
-              cols: colsRef.current,
-              rows: rowsRef.current
-            }));
-            geometryPendingRef.current = false;
-          } catch {
-            try {
-              ws.close();
-            } catch {
-            }
-            settle(false);
-            return;
-          }
-        }
-        if (protocolFailureRef.current) return;
-        wsRef.current = ws;
-      };
-      ws.onmessage = (ev) => {
-        if (!mountedRef.current || !isCurrentSocket()) return;
-        const data = ev.data;
-        let text;
-        if (typeof data === "string") {
-          text = data;
-        } else if (data instanceof ArrayBuffer) {
-          text = new TextDecoder().decode(data);
-        } else if (ArrayBuffer.isView(data)) {
-          text = new TextDecoder().decode(data);
-        } else {
-          data.text().then((t) => {
-            if (mountedRef.current && isCurrentSocket()) onDataRef.current(t);
-          }).catch(() => {
-          });
-          return;
-        }
-        if (typeof data === "string") {
-          try {
-            const event = JSON.parse(text);
-            if (event !== null && typeof event === "object" && !Array.isArray(event)) {
-              const controlFrame = event;
-              switch (controlFrame.type) {
-                case "ready":
-                  transportReadyRef.current = true;
-                  setIsConnected(true);
-                  setError(null);
-                  retryCountRef.current = 0;
-                  settle(true);
-                  return;
-                case "error": {
-                  const message = typeof controlFrame.message === "string" ? controlFrame.message : "Terminal WebSocket error";
-                  if (!transportReadyRef.current) {
-                    failProtocol(message);
-                  } else {
-                    setError(message);
-                  }
-                  return;
-                }
-                case "exit":
-                  transportReadyRef.current = false;
-                  setIsConnected(false);
-                  return;
-                case "rec":
-                case "rec.done":
-                  return;
-                default: {
-                  const frameType = typeof controlFrame.type === "string" ? controlFrame.type : "<missing type>";
-                  failProtocol(`Unknown terminal control frame: ${frameType}`);
-                  return;
-                }
-              }
-            }
-          } catch {
-          }
-        }
-        if (text) onDataRef.current(text);
-      };
-      ws.onerror = () => {
-      };
-      ws.onclose = () => {
-        if (pendingWsRef.current === ws) {
-          pendingWsRef.current = null;
-        }
-        const wasActive = wsRef.current === ws;
-        const wasReady = wasActive && transportReadyRef.current;
-        if (wasActive) {
-          wsRef.current = null;
-          transportReadyRef.current = false;
-        }
-        if (!opened) {
-          settle(false);
-          return;
-        }
-        if (!wasReady) {
-          settle(false);
-          return;
-        }
-        if (protocolFailureRef.current || !wasActive || !mountedRef.current) return;
-        setIsConnected(false);
-        if (sessionIdRef.current) {
-          retryTimerRef.current = setTimeout(() => {
-            if (mountedRef.current && sessionIdRef.current) {
-              if (shouldDeleteSessionRef.current) {
-                connectStreamRef.current?.(sessionIdRef.current);
-              } else {
-                reconnectRef.current?.();
-              }
-            }
-          }, 1e3);
-        }
-      };
-    });
-  }, [apiUrl, rejectPendingInput]);
-  const patchGeometry = useCallback(async (sessionId, cols, rows) => {
-    try {
-      const res = await fetch(`${apiUrl}/terminals/${sessionId}`, {
-        method: "PATCH",
-        headers: {
-          Authorization: `Bearer ${tokenRef.current}`,
-          "Content-Type": "application/json"
-        },
-        credentials: "include",
-        body: JSON.stringify({ cols, rows })
-      });
-      if (!res.ok) {
-        console.error("Failed to resize terminal:", res.status);
-      }
-    } catch (err) {
-      console.error("Failed to resize terminal", err);
-    }
-  }, [apiUrl]);
-  const connectStream = useCallback(async (sessionId) => {
-    if (exactAttachRequiredRef.current) {
-      throw new Error(
-        "Interactive terminal requires an exact WebSocket attachment"
-      );
-    }
-    abortStream();
-    setError(null);
-    try {
-      const controller = new AbortController();
-      abortRef.current = controller;
-      const streamRes = await fetch(`${apiUrl}/terminals/${sessionId}/stream`, {
-        headers: { Authorization: `Bearer ${tokenRef.current}` },
-        credentials: "include",
-        signal: controller.signal
-      });
-      if (!streamRes.ok || !streamRes.body) {
-        const err = new Error(`SSE stream failed: ${streamRes.status}`);
-        err.httpStatus = streamRes.status;
-        throw err;
-      }
-      if (mountedRef.current) {
-        transportReadyRef.current = true;
-        setIsConnected(true);
-        setError(null);
-        retryCountRef.current = 0;
-        ensureDrainRunningRef.current?.();
-        if (geometryPendingRef.current) {
-          geometryPendingRef.current = false;
-          void patchGeometry(sessionId, colsRef.current, rowsRef.current);
-        }
-      }
-      const reader = streamRes.body.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        buffer += decoder.decode(value, { stream: true });
-        const frames = buffer.split("\n\n");
-        buffer = frames.pop() ?? "";
-        for (const frame of frames) {
-          if (!frame.trim()) continue;
-          for (const line of frame.split("\n")) {
-            if (line.startsWith("data:")) {
-              const raw = line.slice(5).trim();
-              if (!raw) continue;
-              try {
-                const event = JSON.parse(raw);
-                if (event.type === "data.stdout" || event.type === "data.stderr") {
-                  const text = event.properties?.text ?? "";
-                  if (text && mountedRef.current) {
-                    onDataRef.current(text);
-                  }
-                }
-              } catch {
-                if (mountedRef.current) {
-                  onDataRef.current(raw);
-                }
-              }
-            }
-          }
-        }
-      }
-      if (mountedRef.current) {
-        transportReadyRef.current = false;
-        setIsConnected(false);
-        retryTimerRef.current = setTimeout(() => {
-          if (mountedRef.current && sessionIdRef.current) {
-            connectStreamRef.current?.(sessionIdRef.current);
-          }
-        }, 1e3);
-      }
-    } catch (err) {
-      if (err.name === "AbortError") return;
-      if (mountedRef.current) {
-        const message = err instanceof Error ? err.message : "Stream connection failed";
-        setError(message);
-        transportReadyRef.current = false;
-        setIsConnected(false);
-        const httpStatus = err.httpStatus;
-        const is4xx = httpStatus !== void 0 && httpStatus >= 400 && httpStatus < 500;
-        const MAX_RETRIES = 8;
-        if (!is4xx && retryCountRef.current < MAX_RETRIES) {
-          const delay = Math.min(3e3 * Math.pow(2, retryCountRef.current), 3e4);
-          retryCountRef.current++;
-          retryTimerRef.current = setTimeout(() => {
-            if (mountedRef.current && sessionIdRef.current) {
-              connectStreamRef.current?.(sessionIdRef.current);
-            }
-          }, delay);
-        }
-      }
-    }
-  }, [apiUrl, abortStream, patchGeometry]);
-  onDataRef.current = onData;
-  tokenRef.current = token;
-  incarnationIdRef.current = incarnationId;
-  controlRef.current = control;
-  exactAttachRequiredRef.current = incarnationId !== void 0 || control !== void 0;
-  connectStreamRef.current = connectStream;
-  const exactIdentityKey = interactiveIdentityKey(incarnationId, control);
-  const connect = useCallback(async () => {
-    cleanup();
-    const myGen = ++connectGenRef.current;
-    protocolFailureRef.current = false;
-    retryCountRef.current = 0;
-    setError(null);
-    if (exactAttachRequiredRef.current && (!incarnationIdRef.current || !controlRef.current)) {
-      setError("Interactive terminal identity is incomplete");
-      return;
-    }
-    try {
-      const connectionId = providedConnectionId ?? createTerminalConnectionId();
-      if (!mountedRef.current) return;
-      sessionIdRef.current = connectionId;
-      shouldDeleteSessionRef.current = false;
-      transportReadyRef.current = false;
-      inputAbortRef.current = new AbortController();
-      const directWsOk = await connectWs(connectionId, { initOnOpen: true });
-      if (!mountedRef.current || connectGenRef.current !== myGen) return;
-      if (protocolFailureRef.current) return;
-      ensureDrainRunningRef.current?.();
-      if (directWsOk) {
-        return;
-      }
-      if (exactAttachRequiredRef.current) {
-        throw new Error(
-          "Interactive terminal WebSocket attach failed; exact identity was not accepted"
-        );
-      }
-      sessionIdRef.current = null;
-      transportReadyRef.current = false;
-      if (inputAbortRef.current) {
-        inputAbortRef.current.abort();
-        inputAbortRef.current = null;
-      }
-      const res = await fetch(`${apiUrl}/terminals`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${tokenRef.current}`,
-          "Content-Type": "application/json"
-        },
-        credentials: "include",
-        body: JSON.stringify({
-          cols: colsRef.current,
-          rows: rowsRef.current
-        })
-      });
-      geometryPendingRef.current = false;
-      if (!res.ok) {
-        throw new Error(`Failed to create terminal: ${res.status}`);
-      }
-      const body = await res.json();
-      const sessionId = body.data?.sessionId ?? body.sessionId;
-      if (!sessionId) throw new Error("No sessionId in response");
-      if (!mountedRef.current) return;
-      sessionIdRef.current = sessionId;
-      shouldDeleteSessionRef.current = true;
-      transportReadyRef.current = false;
-      inputAbortRef.current = new AbortController();
-      const wsOk = await connectWs(sessionId, { initOnOpen: true });
-      if (!mountedRef.current || connectGenRef.current !== myGen) return;
-      if (protocolFailureRef.current) return;
-      ensureDrainRunningRef.current?.();
-      if (wsOk) {
-        return;
-      }
-      await connectStream(sessionId);
-    } catch (err) {
-      if (err.name === "AbortError") return;
-      if (mountedRef.current) {
-        const message = err instanceof Error ? err.message : "Terminal connection failed";
-        setError(message);
-        transportReadyRef.current = false;
-        setIsConnected(false);
-      }
-    }
-  }, [
-    apiUrl,
-    providedConnectionId,
-    cleanup,
-    connectWs,
-    connectStream,
-    exactIdentityKey
-  ]);
-  reconnectRef.current = connect;
-  const resizeTerminal = useCallback(async (cols, rows) => {
-    if (cols > 0) colsRef.current = cols;
-    if (rows > 0) rowsRef.current = rows;
-    const sid = sessionIdRef.current;
-    if (!sid || cols <= 0 || rows <= 0) return;
-    const ws = wsRef.current;
-    if (ws && ws.readyState === WebSocket.OPEN) {
-      try {
-        ws.send(JSON.stringify({ type: "resize", cols, rows }));
-        return;
-      } catch (err) {
-        console.warn("Terminal resize over WS failed; falling back to HTTP", err);
-      }
-    }
-    if (pendingWsRef.current) {
-      geometryPendingRef.current = true;
-      return;
-    }
-    if (exactAttachRequiredRef.current) {
-      throw new Error(
-        "Interactive terminal is not attached with its exact identity"
-      );
-    }
-    await patchGeometry(sid, cols, rows);
-  }, [apiUrl, patchGeometry]);
-  const drainInputQueue = useCallback(async () => {
-    while (pendingBatchRef.current.data.length > 0) {
-      const sid = sessionIdRef.current;
-      if (!sid || !transportReadyRef.current) {
-        return;
-      }
-      const batch = pendingBatchRef.current;
-      pendingBatchRef.current = createEmptyBatch();
-      const ws = wsRef.current;
-      if (ws && ws.readyState === WebSocket.OPEN) {
-        try {
-          ws.send(JSON.stringify({ type: "input", data: batch.data }));
-          for (const w of batch.waiters) w.resolve();
-        } catch (err) {
-          for (const w of batch.waiters) w.reject(err);
-        }
-        continue;
-      }
-      if (exactAttachRequiredRef.current) {
-        for (const w of batch.waiters) {
-          w.reject(
-            new Error(
-              "Interactive terminal is not attached with its exact identity"
-            )
-          );
-        }
-        continue;
-      }
-      try {
-        const res = await fetch(`${apiUrl}/terminals/${sid}/input`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${tokenRef.current}`,
-            "Content-Type": "application/json"
-          },
-          credentials: "include",
-          body: JSON.stringify({ data: batch.data }),
-          signal: inputAbortRef.current?.signal
-        });
-        if (!res.ok) {
-          const text = await res.text().catch(() => "");
-          throw new Error(text || `Input failed: ${res.status}`);
-        }
-        for (const w of batch.waiters) w.resolve();
-      } catch (err) {
-        const isAbort = err?.name === "AbortError";
-        const rejection = isAbort ? new Error("Terminal session is not connected") : err;
-        if (!isAbort) console.error("Failed to send command", err);
-        for (const w of batch.waiters) w.reject(rejection);
-      }
-    }
-  }, [apiUrl]);
-  const ensureDrainRunning = useCallback(() => {
-    if (drainPromiseRef.current) return;
-    const run = () => drainInputQueue().finally(() => {
-      if (pendingBatchRef.current.data.length > 0 && sessionIdRef.current && transportReadyRef.current) {
-        drainPromiseRef.current = run();
-      } else {
-        drainPromiseRef.current = null;
-      }
-    });
-    drainPromiseRef.current = run();
-  }, [drainInputQueue]);
-  ensureDrainRunningRef.current = ensureDrainRunning;
-  const sendCommand = useCallback((command) => {
-    return new Promise((resolve, reject) => {
-      if (command.length === 0) {
-        resolve();
-        return;
-      }
-      if (protocolFailureRef.current) {
-        reject(new Error("Terminal protocol failure"));
-        return;
-      }
-      pendingBatchRef.current.data += command;
-      pendingBatchRef.current.waiters.push({ resolve, reject });
-      ensureDrainRunning();
-    });
-  }, [ensureDrainRunning]);
-  useEffect(() => {
-    mountedRef.current = true;
-    connect();
-    return () => {
-      mountedRef.current = false;
-      cleanup();
-    };
-  }, [connect, cleanup]);
-  return { isConnected, error, sendCommand, resizeTerminal, reconnect: connect };
-}
-
-export {
-  usePtySession
-};