@jfvilas/plugin-kwirth-fileman 0.13.5

package/dist/components/EntityKwirthFilemanContent.esm.js

@@ -0,0 +1,585 @@
+import React, { useState, useRef, useEffect } from 'react';
+import useAsync from 'react-use/esm/useAsync';
+import { Progress, WarningPanel } from '@backstage/core-components';
+import { useApi, alertApiRef } from '@backstage/core-plugin-api';
+import { isKwirthAvailable, ANNOTATION_BACKSTAGE_KUBERNETES_LABELID, ANNOTATION_BACKSTAGE_KUBERNETES_LABELSELECTOR, getPodList, getContainerList } from '@jfvilas/plugin-kwirth-common';
+import { useEntity, MissingAnnotationEmptyState } from '@backstage/plugin-catalog-react';
+import { kwirthFilemanApiRef } from '../api/types.esm.js';
+import { SignalMessageLevelEnum, accessKeySerialize, InstanceMessageTypeEnum, InstanceMessageActionEnum, InstanceMessageFlowEnum, InstanceConfigViewEnum, InstanceConfigObjectEnum, SignalMessageEventEnum } from '@jfvilas/kwirth-common';
+import { ComponentNotFound, ErrorType, ClusterList, KwirthNews, StatusLog } from '@jfvilas/plugin-kwirth-frontend';
+import { Box, Grid, Card, CardHeader, IconButton, Typography } from '@material-ui/core';
+import PlayIcon from '@material-ui/icons/PlayArrow';
+import PauseIcon from '@material-ui/icons/Pause';
+import StopIcon from '@material-ui/icons/Stop';
+import InfoIcon from '@material-ui/icons/Info';
+import WarningIcon from '@material-ui/icons/Warning';
+import ErrorIcon from '@material-ui/icons/Error';
+import KwirthFilemanLogo from '../plugins/plugin-kwirth-fileman/src/assets/kwirthfileman-logo.svg';
+import { v4 } from 'uuid';
+import { FileManager } from '@jfvilas/react-file-manager';
+import '@jfvilas/react-file-manager/dist/style.css';
+import styles from './custom-fm.module.css.esm.js';
+import { VERSION } from '../version.esm.js';
+
+const EntityKwirthFilemanContent = (props) => {
+  const { entity } = useEntity();
+  const kwirthFilemanApi = useApi(kwirthFilemanApiRef);
+  const alertApi = useApi(alertApiRef);
+  const [validClusters, setResources] = useState([]);
+  const [selectedClusterName, setSelectedClusterName] = useState("");
+  const [selectedNamespaces, setSelectedNamespaces] = useState([]);
+  const [selectedPodNames, setSelectedPodNames] = useState([]);
+  const [selectedContainerNames, setSelectedContainerNames] = useState([]);
+  const [started, setStarted] = useState(false);
+  const [stopped, setStopped] = useState(true);
+  const paused = useRef(false);
+  const [statusMessages, setStatusMessages] = useState([]);
+  const [webSocket, setWebSocket] = useState();
+  const [showStatusDialog, setShowStatusDialog] = useState(false);
+  const [statusLevel, setStatusLevel] = useState(SignalMessageLevelEnum.INFO);
+  const [backendVersion, setBackendVersion] = useState("");
+  const [backendInfo, setBackendInfo] = useState();
+  const instance = useRef();
+  const [stateFiles, setStateFiles] = useState([]);
+  const files = useRef([]);
+  const [currentPath, setCurrentPath] = useState("");
+  const { loading, error } = useAsync(async () => {
+    if (backendVersion === "") setBackendVersion(await kwirthFilemanApi.getVersion());
+    if (!backendInfo) setBackendInfo(await kwirthFilemanApi.getInfo());
+    let reqScopes = ["fileman$read"];
+    let data = await kwirthFilemanApi.requestAccess(entity, "fileman", reqScopes);
+    setResources(data);
+  });
+  const filemanBoxRef = useRef(null);
+  const [filemanBoxTop, setFilemanBoxTop] = useState(0);
+  let permissions = {
+    create: true,
+    delete: true,
+    download: true,
+    copy: true,
+    move: true,
+    rename: true,
+    upload: true
+  };
+  let fileUploadConfig = {
+    url: ""
+  };
+  let cluster = validClusters.find((cluster2) => cluster2.name === selectedClusterName);
+  if (cluster) {
+    let accessKey = cluster.accessKeys.get("fileman$read");
+    if (accessKey) {
+      fileUploadConfig = {
+        url: `${cluster.url}/channel/fileman/upload?key=${instance.current}`,
+        method: "POST",
+        headers: {
+          "Authorization": "Bearer " + accessKeySerialize(accessKey)
+        }
+      };
+    }
+  }
+  let level = currentPath.split("/").length - 1;
+  if (level < 3) {
+    permissions = {
+      create: false,
+      delete: false,
+      download: false,
+      copy: false,
+      move: false,
+      rename: false,
+      upload: false
+    };
+  }
+  useEffect(() => {
+    if (filemanBoxRef.current) setFilemanBoxTop(filemanBoxRef.current.getBoundingClientRect().top);
+  });
+  const clickStart = () => {
+    if (!paused.current) {
+      setStarted(true);
+      paused.current = false;
+      setStopped(false);
+      startFilemanViewer();
+    } else {
+      paused.current = false;
+      setStarted(true);
+    }
+  };
+  const onClickPause = () => {
+    setStarted(false);
+    paused.current = true;
+  };
+  const onClickStop = () => {
+    setStarted(false);
+    setStopped(true);
+    paused.current = false;
+    stopFilemanViewer();
+  };
+  const onSelectCluster = (clusterName) => {
+    if (started) onClickStop();
+    if (clusterName) {
+      setSelectedClusterName(clusterName);
+      setSelectedPodNames([]);
+      setSelectedContainerNames([]);
+      setStatusMessages([]);
+      let cluster2 = validClusters.find((cluster3) => cluster3.name === clusterName);
+      if (cluster2 && cluster2.pods) {
+        let validNamespaces = Array.from(new Set(cluster2.pods.map((pod) => pod.namespace)));
+        if (validNamespaces.length === 1) {
+          setSelectedNamespaces(validNamespaces);
+          let podList = getPodList(cluster2.pods, validNamespaces);
+          setSelectedPodNames(podList.map((pod) => pod.name));
+          setSelectedContainerNames(getContainerList(cluster2.pods, validNamespaces, podList.map((pod) => pod.name), props.excludeContainers || []));
+        } else {
+          setSelectedNamespaces([]);
+        }
+      }
+    }
+  };
+  let FilemanCommandEnum;
+  ((FilemanCommandEnum2) => {
+    FilemanCommandEnum2["HOME"] = "home";
+    FilemanCommandEnum2["DIR"] = "dir";
+    FilemanCommandEnum2["CREATE"] = "create";
+    FilemanCommandEnum2["RENAME"] = "rename";
+    FilemanCommandEnum2["DELETE"] = "delete";
+    FilemanCommandEnum2["MOVE"] = "move";
+    FilemanCommandEnum2["COPY"] = "copy";
+    FilemanCommandEnum2["UPLOAD"] = "upload";
+    FilemanCommandEnum2["DOWNLOAD"] = "download";
+  })(FilemanCommandEnum || (FilemanCommandEnum = {}));
+  const processFilemanMessage = (wsEvent) => {
+    let msg = JSON.parse(wsEvent.data);
+    switch (msg.type) {
+      case InstanceMessageTypeEnum.DATA: {
+        let response = JSON.parse(wsEvent.data);
+        switch (response.action) {
+          case InstanceMessageActionEnum.COMMAND:
+            {
+              switch (response.command) {
+                case "home" /* HOME */:
+                  let data = response.data;
+                  let nss = Array.from(new Set(data.map((n) => n.split("/")[0])));
+                  nss.map((ns) => {
+                    if (!files.current.some((f) => f.path === "/" + ns)) {
+                      files.current.push({ name: ns, isDirectory: true, path: "/" + ns, class: "namespace" });
+                    }
+                    let podNames = Array.from(new Set(data.filter((a) => a.split("/")[0] === ns).map((o) => o.split("/")[1])));
+                    podNames.map((p) => {
+                      if (!files.current.some((f) => f.path === "/" + ns + "/" + p)) {
+                        files.current.push({ name: p, isDirectory: true, path: "/" + ns + "/" + p, class: "pod" });
+                      }
+                      let conts = Array.from(new Set(data.filter((a) => a.split("/")[0] === ns && a.split("/")[1] === p).map((o) => o.split("/")[2])));
+                      conts.map((c) => {
+                        if (!files.current.some((f) => f.path === "/" + ns + "/" + p + "/" + c)) {
+                          files.current.push({ name: c, isDirectory: true, path: "/" + ns + "/" + p + "/" + c, class: "container" });
+                        }
+                      });
+                    });
+                  });
+                  setStateFiles([...files.current]);
+                  break;
+                case "dir" /* DIR */:
+                  let content = JSON.parse(response.data);
+                  if (content.status === "Success") {
+                    for (let o of content.metadata.object) {
+                      let name = o.name.split("/")[o.name.split("/").length - 1];
+                      let e = {
+                        name,
+                        isDirectory: o.type === 1,
+                        path: o.name,
+                        updatedAt: (/* @__PURE__ */ new Date(+o.time)).toISOString(),
+                        size: +o.size,
+                        ...o.type === 0 ? { class: "file" } : {}
+                      };
+                      let i = files.current.findIndex((f) => f.path === e.path);
+                      if (i >= 0)
+                        files.current[i] = e;
+                      else
+                        files.current.push(e);
+                    }
+                    setStateFiles([...files.current]);
+                  } else {
+                    addMessage(SignalMessageLevelEnum.ERROR, content.text || content.message);
+                  }
+                  break;
+                case "rename" /* RENAME */:
+                  {
+                    let content2 = JSON.parse(response.data);
+                    if (content2.status !== "Success") addMessage(SignalMessageLevelEnum.ERROR, content2.text || content2.message);
+                  }
+                  break;
+                case "delete" /* DELETE */: {
+                  let content2 = JSON.parse(response.data);
+                  if (content2.status === "Success") {
+                    let fname = content2.metadata.object;
+                    files.current = files.current.filter((f) => f.path !== fname);
+                    files.current = files.current.filter((f) => !f.path.startsWith(fname + "/"));
+                    setStateFiles([...files.current]);
+                  } else {
+                    addMessage(SignalMessageLevelEnum.ERROR, content2.text || content2.message);
+                  }
+                  break;
+                }
+                case "move" /* MOVE */:
+                case "copy" /* COPY */:
+                case "create" /* CREATE */: {
+                  let content2 = JSON.parse(response.data);
+                  if (content2.status === "Success") {
+                    let f = {
+                      name: content2.metadata.object.split("/").slice(-1)[0],
+                      isDirectory: content2.metadata.type === 1,
+                      path: content2.metadata.object,
+                      updatedAt: (/* @__PURE__ */ new Date(+content2.metadata.time)).toISOString(),
+                      size: +content2.metadata.size,
+                      ...content2.metadata.type.type === 0 ? { class: "file" } : {}
+                    };
+                    files.current.push(f);
+                    setStateFiles([...files.current]);
+                  } else {
+                    addMessage(SignalMessageLevelEnum.ERROR, content2.text || content2.message);
+                  }
+                  break;
+                }
+              }
+            }
+            break;
+        }
+        break;
+      }
+      case InstanceMessageTypeEnum.SIGNAL:
+        let signalMessage = JSON.parse(wsEvent.data);
+        if (signalMessage.flow === InstanceMessageFlowEnum.RESPONSE) {
+          if (signalMessage.action === InstanceMessageActionEnum.START) {
+            if (signalMessage.text) addMessage(SignalMessageLevelEnum.INFO, signalMessage.text);
+            instance.current = signalMessage.instance;
+          } else {
+            addMessage(SignalMessageLevelEnum.ERROR, wsEvent.data);
+          }
+        } else if (signalMessage.flow === InstanceMessageFlowEnum.UNSOLICITED) {
+          let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+          if (cluster2) {
+            let accessKey = cluster2.accessKeys.get("fileman$read");
+            if (accessKey && instance?.current) {
+              if (signalMessage.event === SignalMessageEventEnum.ADD) {
+                let filemanMessage = {
+                  flow: InstanceMessageFlowEnum.REQUEST,
+                  action: InstanceMessageActionEnum.COMMAND,
+                  channel: "fileman",
+                  type: InstanceMessageTypeEnum.DATA,
+                  accessKey: accessKeySerialize(accessKey),
+                  instance: instance.current,
+                  id: v4(),
+                  command: "home" /* HOME */,
+                  namespace: signalMessage.namespace,
+                  group: "",
+                  pod: signalMessage.pod,
+                  container: signalMessage.container,
+                  params: [],
+                  msgtype: "filemanmessage"
+                };
+                let payload = JSON.stringify(filemanMessage);
+                wsEvent.target.send(payload);
+                if (signalMessage.text) addMessage(SignalMessageLevelEnum.INFO, signalMessage.text);
+              }
+            } else {
+              addMessage(SignalMessageLevelEnum.INFO, "Have no instance/accessKey");
+            }
+          } else {
+            addMessage(SignalMessageLevelEnum.INFO, "Have no cluster");
+          }
+        }
+        break;
+      default:
+        console.log(`Invalid message type ${msg.type}`);
+        break;
+    }
+  };
+  const addMessage = (level2, text) => {
+    alertApi.post({ message: text, severity: level2, display: "transient" });
+    setStatusMessages((prev) => [...prev, {
+      level: level2,
+      text,
+      type: InstanceMessageTypeEnum.SIGNAL
+    }]);
+  };
+  const websocketOnMessage = (wsEvent) => {
+    let instanceMessage;
+    try {
+      instanceMessage = JSON.parse(wsEvent.data);
+    } catch (err) {
+      console.log(err);
+      console.log(wsEvent.data);
+      return;
+    }
+    switch (instanceMessage.channel) {
+      case "fileman":
+        processFilemanMessage(wsEvent);
+        break;
+      default:
+        addMessage(SignalMessageLevelEnum.ERROR, "Invalid channel in message: " + instanceMessage.channel);
+        addMessage(SignalMessageLevelEnum.ERROR, "Invalid message: " + JSON.stringify(instanceMessage));
+        break;
+    }
+  };
+  const websocketOnOpen = (ws) => {
+    setWebSocket(ws);
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (!cluster2) {
+      addMessage(SignalMessageLevelEnum.ERROR, "No cluster selected");
+      return;
+    }
+    let pods = cluster2.pods.filter((p2) => selectedNamespaces.includes(p2.namespace));
+    if (!pods) {
+      addMessage(SignalMessageLevelEnum.ERROR, "No pods found");
+      return;
+    }
+    console.log(`WS connected`);
+    let accessKey = cluster2.accessKeys.get("fileman$read");
+    if (accessKey) {
+      let containers = [];
+      if (selectedContainerNames.length > 0) {
+        for (var p of selectedPodNames) {
+          for (var c of selectedContainerNames) {
+            containers.push(p + "+" + c);
+          }
+        }
+      }
+      let iConfig = {
+        channel: "fileman",
+        objects: InstanceConfigObjectEnum.PODS,
+        action: InstanceMessageActionEnum.START,
+        flow: InstanceMessageFlowEnum.REQUEST,
+        instance: "",
+        accessKey: accessKeySerialize(accessKey),
+        scope: "fileman$read",
+        view: selectedContainerNames.length > 0 ? InstanceConfigViewEnum.CONTAINER : InstanceConfigViewEnum.POD,
+        namespace: selectedNamespaces.join(","),
+        group: "",
+        pod: selectedPodNames.map((p2) => p2).join(","),
+        container: containers.join(","),
+        data: {},
+        type: InstanceMessageTypeEnum.SIGNAL
+      };
+      ws.send(JSON.stringify(iConfig));
+    } else {
+      addMessage(SignalMessageLevelEnum.ERROR, "No accessKey for starting fileman streaming");
+      return;
+    }
+  };
+  const startFilemanViewer = () => {
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (!cluster2) {
+      addMessage(SignalMessageLevelEnum.ERROR, "No cluster selected");
+      return;
+    }
+    try {
+      let ws = new WebSocket(cluster2.url);
+      ws.onopen = () => websocketOnOpen(ws);
+      ws.onmessage = (event) => websocketOnMessage(event);
+      ws.onclose = (event) => websocketOnClose(event);
+      setWebSocket(ws);
+    } catch (err) {
+    }
+  };
+  const websocketOnClose = (_event) => {
+    console.log(`WS disconnected`);
+    setStarted(false);
+    paused.current = false;
+    setStopped(true);
+  };
+  const stopFilemanViewer = () => {
+    webSocket?.close();
+  };
+  const actionButtons = () => {
+    let hasKey = false;
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (cluster2) {
+      hasKey = Boolean(cluster2.accessKeys.get("fileman$read"));
+    }
+    return /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(IconButton, { onClick: () => clickStart(), title: "Play", disabled: started || !paused || selectedPodNames.length === 0 || !hasKey }, /* @__PURE__ */ React.createElement(PlayIcon, null)), /* @__PURE__ */ React.createElement(IconButton, { onClick: onClickPause, title: "Pause", disabled: !(started && !paused.current && selectedPodNames.length > 0) }, /* @__PURE__ */ React.createElement(PauseIcon, null)), /* @__PURE__ */ React.createElement(IconButton, { onClick: onClickStop, title: "Stop", disabled: stopped || selectedPodNames.length === 0 }, /* @__PURE__ */ React.createElement(StopIcon, null)));
+  };
+  const statusButtons = (title) => {
+    const show = (level2) => {
+      setShowStatusDialog(true);
+      setStatusLevel(level2);
+    };
+    const prepareText = (txt) => {
+      return txt ? txt.length > 25 ? txt.substring(0, 25) + "..." : txt : "N/A";
+    };
+    return /* @__PURE__ */ React.createElement(Grid, { container: true, direction: "row" }, /* @__PURE__ */ React.createElement(Grid, { item: true }, /* @__PURE__ */ React.createElement(Typography, { variant: "h5" }, prepareText(title))), /* @__PURE__ */ React.createElement(Grid, { item: true, style: { marginTop: "-8px" } }, /* @__PURE__ */ React.createElement(IconButton, { title: "info", disabled: !statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.INFO), onClick: () => show(SignalMessageLevelEnum.INFO) }, /* @__PURE__ */ React.createElement(InfoIcon, { style: { color: statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.INFO) ? "blue" : "#BDBDBD" } })), /* @__PURE__ */ React.createElement(IconButton, { title: "warning", disabled: !statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.WARNING), onClick: () => show(SignalMessageLevelEnum.WARNING), style: { marginLeft: "-16px" } }, /* @__PURE__ */ React.createElement(WarningIcon, { style: { color: statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.WARNING) ? "orange" : "#BDBDBD" } })), /* @__PURE__ */ React.createElement(IconButton, { title: "error", disabled: !statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.ERROR), onClick: () => show(SignalMessageLevelEnum.ERROR), style: { marginLeft: "-16px" } }, /* @__PURE__ */ React.createElement(ErrorIcon, { style: { color: statusMessages.some((m) => m.type === InstanceMessageTypeEnum.SIGNAL && m.level === SignalMessageLevelEnum.ERROR) ? "red" : "#BDBDBD" } }))));
+  };
+  const statusClear = (level2) => {
+    setStatusMessages(statusMessages.filter((m) => m.level !== level2));
+    setShowStatusDialog(false);
+  };
+  const onError = (error2, _file) => {
+    addMessage(SignalMessageLevelEnum.ERROR, error2.message);
+  };
+  const onRename = (file, newName) => {
+    let [namespace, pod, container] = file.path.split("/").slice(1);
+    files.current = files.current.filter((f) => f.path !== file.path);
+    setStateFiles([...files.current]);
+    sendCommand("rename" /* RENAME */, namespace, pod, container, [file.path, newName]);
+  };
+  const onRefresh = () => {
+    if (level >= 3) {
+      files.current = files.current.filter((f) => !f.path.startsWith(currentPath + "/"));
+      getLocalDir(currentPath + "/");
+    } else {
+      sendCommand("home" /* HOME */, "", "", "", []);
+    }
+  };
+  const getLocalDir = (folder) => {
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (cluster2) {
+      let accessKey = cluster2.accessKeys.get("fileman$read");
+      if (accessKey && instance?.current && webSocket) {
+        let [namespace, pod, container] = folder.split("/").slice(1);
+        let filemanMessage = {
+          flow: InstanceMessageFlowEnum.REQUEST,
+          action: InstanceMessageActionEnum.COMMAND,
+          channel: "fileman",
+          type: InstanceMessageTypeEnum.DATA,
+          accessKey: accessKeySerialize(accessKey),
+          instance: instance.current,
+          id: v4(),
+          command: "dir" /* DIR */,
+          namespace,
+          group: "",
+          pod,
+          container,
+          params: [folder],
+          msgtype: "filemanmessage"
+        };
+        let payload = JSON.stringify(filemanMessage);
+        webSocket.send(payload);
+      }
+    }
+  };
+  const sendCommand = (command, namespace, pod, container, params) => {
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (cluster2) {
+      let accessKey = cluster2.accessKeys.get("fileman$read");
+      if (accessKey && instance?.current && webSocket) {
+        let filemanMessage = {
+          flow: InstanceMessageFlowEnum.REQUEST,
+          action: InstanceMessageActionEnum.COMMAND,
+          channel: "fileman",
+          type: InstanceMessageTypeEnum.DATA,
+          accessKey: accessKeySerialize(accessKey),
+          instance: instance.current,
+          id: v4(),
+          command,
+          namespace,
+          group: "",
+          pod,
+          container,
+          params,
+          msgtype: "filemanmessage"
+        };
+        let payload = JSON.stringify(filemanMessage);
+        webSocket.send(payload);
+      } else {
+        addMessage(SignalMessageLevelEnum.ERROR, "Have no instance/accessKey");
+      }
+    } else {
+      addMessage(SignalMessageLevelEnum.ERROR, "Have no cluster");
+    }
+  };
+  const onDelete = async (filesToDelete) => {
+    for (let file of filesToDelete) {
+      let [namespace, pod, container] = file.path.split("/").slice(1);
+      sendCommand("delete" /* DELETE */, namespace, pod, container, [file.path]);
+    }
+  };
+  const onCreateFolder = async (name, parentFolder) => {
+    let [namespace, pod, container] = parentFolder.path.split("/").slice(1);
+    sendCommand("create" /* CREATE */, namespace, pod, container, [parentFolder.path + "/" + name]);
+  };
+  const onDownload = async (filesToDownload) => {
+    let cluster2 = validClusters.find((cluster3) => cluster3.name === selectedClusterName);
+    if (cluster2) {
+      let accessKey = cluster2.accessKeys.get("fileman$read");
+      if (accessKey) {
+        for (let file of filesToDownload) {
+          const url = `${cluster2.url}/channel/fileman/download?key=${instance.current}&filename=${file.path}`;
+          try {
+            const response = await fetch(url, { headers: { "Authorization": "Bearer " + accessKeySerialize(accessKey) } });
+            if (response.ok) {
+              const blob = await response.blob();
+              const link = document.createElement("a");
+              link.href = URL.createObjectURL(blob);
+              link.download = file.path.split("/").slice(-1)[0];
+              if (file.isDirectory) link.download += ".tar.gz";
+              document.body.appendChild(link);
+              link.click();
+              document.body.removeChild(link);
+              URL.revokeObjectURL(link.href);
+            } else {
+              console.error(`Error downloading file: ${file.path}`);
+              addMessage(SignalMessageLevelEnum.ERROR, `Error downloading file ${file.path}: (${response.status}) ${await response.text()}`);
+            }
+          } catch (error2) {
+            console.error(`Error downloading file: ${file.path}`, error2);
+            addMessage(SignalMessageLevelEnum.ERROR, `Error downloading file ${file.path}: ${error2}`);
+          }
+        }
+      } else {
+        addMessage(SignalMessageLevelEnum.ERROR, "Have no instance/accessKey");
+      }
+    } else {
+      addMessage(SignalMessageLevelEnum.ERROR, "Have no cluster");
+    }
+  };
+  const onPaste = (filesToPaste, destFolder, operation) => {
+    let command = operation === "move" ? "move" /* MOVE */ : "copy" /* COPY */;
+    for (let file of filesToPaste) {
+      let [namespace, pod, container] = file.path.split("/").slice(1);
+      sendCommand(command, namespace, pod, container, [file.path, destFolder.path]);
+    }
+  };
+  const onFolderChange = (folder) => {
+    setCurrentPath(folder);
+    folder += "/";
+    let level2 = folder.split("/").length - 1;
+    if (level2 > 3) getLocalDir(folder);
+  };
+  const onFileUploading = (file, _parentFolder) => {
+    return { filename: currentPath + "/" + file.name };
+  };
+  return /* @__PURE__ */ React.createElement(React.Fragment, null, loading && /* @__PURE__ */ React.createElement(Progress, null), !isKwirthAvailable(entity) && !loading && error && /* @__PURE__ */ React.createElement(WarningPanel, { title: "An error has ocurred while obtaining data from kuebernetes clusters.", message: error?.message }), !isKwirthAvailable(entity) && !loading && /* @__PURE__ */ React.createElement(MissingAnnotationEmptyState, { readMoreUrl: "https://github.com/jfvilas/plugin-kwirth-fileman", annotation: [ANNOTATION_BACKSTAGE_KUBERNETES_LABELID, ANNOTATION_BACKSTAGE_KUBERNETES_LABELSELECTOR] }), isKwirthAvailable(entity) && !loading && validClusters && validClusters.length === 0 && /* @__PURE__ */ React.createElement(ComponentNotFound, { error: ErrorType.NO_CLUSTERS, entity }), isKwirthAvailable(entity) && !loading && validClusters && validClusters.length > 0 && validClusters.reduce((sum, cluster2) => sum + cluster2.pods.length, 0) === 0 && /* @__PURE__ */ React.createElement(ComponentNotFound, { error: ErrorType.NO_PODS, entity }), isKwirthAvailable(entity) && !loading && validClusters && validClusters.length > 0 && validClusters.reduce((sum, cluster2) => sum + cluster2.pods.length, 0) > 0 && /* @__PURE__ */ React.createElement(Box, { sx: { display: "flex", height: "100%" } }, /* @__PURE__ */ React.createElement(Box, { sx: { width: "200px", maxWidth: "200px" } }, /* @__PURE__ */ React.createElement(Grid, { container: true, direction: "column" }, /* @__PURE__ */ React.createElement(Grid, { item: true }, /* @__PURE__ */ React.createElement(Card, null, /* @__PURE__ */ React.createElement(ClusterList, { resources: validClusters, selectedClusterName, onSelect: onSelectCluster }))), !props.hideVersion && /* @__PURE__ */ React.createElement(Grid, { item: true }, /* @__PURE__ */ React.createElement(Card, null, /* @__PURE__ */ React.createElement(KwirthNews, { latestVersions: backendInfo, backendVersion, ownVersion: VERSION }))))), /* @__PURE__ */ React.createElement(Box, { sx: { flexGrow: 1, flex: 1, overflow: "hidden", p: 1, marginLeft: "8px" } }, !selectedClusterName && /* @__PURE__ */ React.createElement("img", { src: KwirthFilemanLogo, alt: "No cluster selected", style: { left: "40%", marginTop: "10%", width: "20%", position: "relative" } }), selectedClusterName && /* @__PURE__ */ React.createElement(React.Fragment, null, /* @__PURE__ */ React.createElement(Card, { style: { marginTop: -8, marginBottom: "8px" } }, /* @__PURE__ */ React.createElement(
+    CardHeader,
+    {
+      title: statusButtons(selectedClusterName),
+      style: { marginTop: -4, marginBottom: 4, flexShrink: 0 },
+      action: actionButtons()
+    }
+  )), started && /* @__PURE__ */ React.createElement(Grid, { ref: filemanBoxRef, style: { height: `calc(100vh - ${filemanBoxTop}px - 35px)` } }, /* @__PURE__ */ React.createElement(
+    FileManager,
+    {
+      className: styles.customFm,
+      files: stateFiles,
+      filePreviewPath: "http://avoid-console-error",
+      primaryColor: "#1976d2",
+      fontFamily: '"Helvetica Neue", Helvetica, Roboto, Arial, sans-serif',
+      height: "100%",
+      actions: /* @__PURE__ */ new Map(),
+      icons: /* @__PURE__ */ new Map(),
+      fileUploadConfig,
+      onCreateFolder,
+      onError,
+      onRename,
+      onPaste,
+      onDelete,
+      onFolderChange,
+      onRefresh,
+      onFileUploading,
+      onDownload,
+      enableFilePreview: false,
+      initialPath: "",
+      permissions
+    }
+  ))))), showStatusDialog && /* @__PURE__ */ React.createElement(StatusLog, { level: statusLevel, onClose: () => setShowStatusDialog(false), statusMessages, onClear: statusClear }));
+};
+
+export { EntityKwirthFilemanContent };
+//# sourceMappingURL=EntityKwirthFilemanContent.esm.js.map