@kwirthmagnify/kwirth-plugin-status 0.1.0

package/back.js

@@ -0,0 +1,242 @@
+"use strict";
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+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);
+
+// kwirth-back-globals:@kwirthmagnify/kwirth-common-back
+var require_kwirth_common_back = __commonJS({
+  "kwirth-back-globals:@kwirthmagnify/kwirth-common-back"(exports2, module2) {
+    module2.exports = global.__kwirth_back__.kwirthCommonBack;
+  }
+});
+
+// src/back/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StatusChannel: () => StatusChannel,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_kwirth_common_back = __toESM(require_kwirth_common_back(), 1);
+var StatusChannel = class {
+  constructor(clusterInfo, backChannelObject) {
+    this.channelId = "status";
+    /*
+        Sin providers y sin almacenamiento. Declarar un provider aquí lo ARRANCARÍA como efecto colateral
+        de tener instalado un visor de estado —el core instancia lo que algún canal declara—, y entonces
+        esta pantalla estaría modificando justo lo que dice observar.
+    */
+    this.requirements = { storage: false, providers: [] };
+    this.webSockets = [];
+    this.getChannelData = () => ({
+      id: "status",
+      routable: false,
+      pauseable: false,
+      // no hay flujo que pausar: es una foto bajo demanda
+      modifiable: false,
+      reconnectable: true,
+      metrics: false,
+      sources: [import_kwirth_common_back.EClusterType.KUBERNETES, import_kwirth_common_back.EClusterType.DOCKER],
+      endpoints: [],
+      websocket: false,
+      cluster: true,
+      // lo que se mira es el Kwirth entero, no un pod
+      resourced: false
+    });
+    /*
+        Ver el inventario completo es una vista privilegiada: enseña todas las extensiones montadas y su
+        estado. Por eso el nivel mínimo es 'cluster' y no hay escalón por namespace — no tendría sentido
+        un inventario "de un namespace", y dejarlo en 'none' lo abriría a cualquiera.
+    */
+    this.getChannelScopeLevel = (scope) => ["", "none", "cluster"].indexOf(scope);
+    this.startChannel = async () => {
+    };
+    this.addObject = async (webSocket, instanceConfig, _ns, _pod, _container) => {
+      let socket = this.webSockets.find((s) => s.ws === webSocket);
+      if (!socket) {
+        socket = { ws: webSocket, lastRefresh: Date.now(), instanceIds: [] };
+        this.webSockets.push(socket);
+      }
+      if (!socket.instanceIds.includes(instanceConfig.instance)) socket.instanceIds.push(instanceConfig.instance);
+      this.sendInventory(socket, instanceConfig.instance);
+      return true;
+    };
+    this.deleteObject = async (_webSocket, _instanceConfig, _ns, _pod, _container) => true;
+    this.pauseContinueInstance = (_webSocket, _instanceConfig, _action) => {
+    };
+    this.modifyInstance = (_webSocket, _instanceConfig) => {
+    };
+    this.containsInstance = (instanceId) => this.webSockets.some((socket) => socket.instanceIds.includes(instanceId));
+    this.containsAsset = (_webSocket, _podNamespace, _podName, _containerName) => false;
+    this.stopInstance = (webSocket, instanceConfig) => {
+      this.removeInstance(webSocket, instanceConfig.instance);
+    };
+    this.removeInstance = (webSocket, instanceId) => {
+      const socket = this.webSockets.find((s) => s.ws === webSocket);
+      if (!socket) return;
+      const pos = socket.instanceIds.indexOf(instanceId);
+      if (pos >= 0) socket.instanceIds.splice(pos, 1);
+    };
+    /*
+        Volver a pedir la foto. Es la ÚNICA forma de que este canal haga trabajo: alguien con la pantalla
+        abierta pulsa refrescar. No hay refresco automático a propósito — sería recolección disfrazada.
+    */
+    this.processCommand = async (webSocket, instanceMessage) => {
+      if (instanceMessage.flow === import_kwirth_common_back.EInstanceMessageFlow.IMMEDIATE) return false;
+      const socket = this.webSockets.find((s) => s.ws === webSocket);
+      if (!socket || !socket.instanceIds.includes(instanceMessage.instance)) {
+        this.sendSignalMessage(webSocket, instanceMessage.action, import_kwirth_common_back.EInstanceMessageFlow.RESPONSE, import_kwirth_common_back.ESignalMessageLevel.ERROR, instanceMessage.instance, "Status instance not found");
+        return false;
+      }
+      this.sendInventory(socket, instanceMessage.instance);
+      return true;
+    };
+    this.containsConnection = (webSocket) => Boolean(this.webSockets.find((s) => s.ws === webSocket));
+    this.removeConnection = (webSocket) => {
+      const pos = this.webSockets.findIndex((s) => s.ws === webSocket);
+      if (pos >= 0) this.webSockets.splice(pos, 1);
+    };
+    this.refreshConnection = (webSocket) => {
+      const socket = this.webSockets.find((s) => s.ws === webSocket);
+      if (!socket) return false;
+      socket.lastRefresh = Date.now();
+      return true;
+    };
+    this.updateConnection = (newWebSocket, instanceId) => {
+      for (const entry of this.webSockets) {
+        if (entry.instanceIds.includes(instanceId)) {
+          entry.ws = newWebSocket;
+          return true;
+        }
+      }
+      return false;
+    };
+    // ---- el inventario -------------------------------------------------------
+    /*
+            Estado de un provider con lo que el core sabe HOY.
+    
+            Deliberadamente NO se distingue "activo" de "ocioso": para eso hay que preguntarle al provider
+            cuántos suscriptores tiene, y ese contrato todavía no existe (llega en S2). Inventar el dato sería
+            peor que no darlo — un administrador que lea "ocioso" va a ir a desinstalar algo.
+        */
+    this.healthOfProvider = (p) => {
+      if (p.started !== true) {
+        return {
+          health: "not-instantiated" /* NOT_INSTANTIATED */,
+          // El core solo instancia los providers que algún canal declara en sus requirements.
+          reason: "No installed channel declares this provider, so the core never started it"
+        };
+      }
+      if (p.configRouter && p.configRouterStarted !== true) {
+        return {
+          health: "pending-restart" /* PENDING_RESTART */,
+          reason: "Its configuration endpoint is not mounted \u2014 the server has not been restarted since it was installed"
+        };
+      }
+      return { health: "instantiated" /* INSTANTIATED */ };
+    };
+    this.buildInventory = () => {
+      const components = [];
+      for (const p of this.clusterInfo.providers ?? []) {
+        const { health, reason } = this.healthOfProvider(p);
+        components.push({ kind: "provider" /* PROVIDER */, id: p.id, displayName: p.id, health, ...reason ? { reason } : {} });
+      }
+      for (const pluviderId of (this.clusterInfo.pluviders ?? /* @__PURE__ */ new Map()).keys()) {
+        components.push({
+          kind: "pluvider" /* PLUVIDER */,
+          id: pluviderId,
+          displayName: pluviderId,
+          health: "instantiated" /* INSTANTIATED */
+        });
+      }
+      for (const s of this.clusterInfo.senders?.listSenders() ?? []) {
+        components.push({
+          kind: "sender" /* SENDER */,
+          id: s.id,
+          displayName: s.id,
+          health: "instantiated" /* INSTANTIATED */,
+          reason: s.configNames.length === 0 ? "Installed, but it has no configuration yet, so it cannot deliver anything" : void 0
+        });
+      }
+      for (const w of this.clusterInfo.webhooks?.listWebhooks() ?? []) {
+        components.push({
+          kind: "webhook" /* WEBHOOK */,
+          id: w.id,
+          displayName: w.id,
+          health: "instantiated" /* INSTANTIATED */,
+          reason: w.configNames.length === 0 ? "Installed, but it has no configuration yet, so nothing can reach it" : void 0
+        });
+      }
+      return {
+        cluster: this.clusterInfo.name ?? "",
+        takenAt: Date.now(),
+        components
+      };
+    };
+    this.sendInventory = (socket, instanceId) => {
+      const msg = {
+        msgtype: "statusmessageresponse",
+        channel: this.channelId,
+        action: import_kwirth_common_back.EInstanceMessageAction.NONE,
+        flow: import_kwirth_common_back.EInstanceMessageFlow.UNSOLICITED,
+        type: import_kwirth_common_back.EInstanceMessageType.DATA,
+        instance: instanceId,
+        payloadType: "inventory" /* INVENTORY */,
+        inventory: this.buildInventory()
+      };
+      socket.ws.send(JSON.stringify(msg));
+    };
+    this.sendSignalMessage = (ws, action, flow, level, instanceId, text) => {
+      const msg = {
+        action,
+        flow,
+        level,
+        channel: this.channelId,
+        instance: instanceId,
+        type: import_kwirth_common_back.EInstanceMessageType.SIGNAL,
+        text
+      };
+      ws.send(JSON.stringify(msg));
+    };
+    this.clusterInfo = clusterInfo;
+    this.backChannelObject = backChannelObject;
+  }
+  processProviderEvent(_providerId, _obj) {
+  }
+  endpointRequest(_endpoint, _req, _res, _accessKey) {
+  }
+  websocketRequest(_newWebSocket, _instanceId, _instanceConfig) {
+  }
+};
+var index_default = StatusChannel;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StatusChannel
+});

package/front.js

@@ -0,0 +1,259 @@
+"use strict";
+(() => {
+  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 __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
+  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
+  ));
+
+  // kwirth-globals:react
+  var require_react = __commonJS({
+    "kwirth-globals:react"(exports, module) {
+      var _m = window.__kwirth__.React;
+      var _d = _m != null && "default" in Object(_m) ? _m.default : _m;
+      if (typeof _d !== "function" && _d != null && typeof _d.default !== "undefined") _d = _d.default;
+      module.exports = Object.assign({}, typeof _m === "object" && _m !== null ? _m : {}, { default: _d, __esModule: true });
+    }
+  });
+
+  // kwirth-globals:@kwirthmagnify/kwirth-common
+  var require_kwirth_common = __commonJS({
+    "kwirth-globals:@kwirthmagnify/kwirth-common"(exports, module) {
+      var _m = window.__kwirth__.kwirthCommon;
+      var _d = _m != null && "default" in Object(_m) ? _m.default : _m;
+      if (typeof _d !== "function" && _d != null && typeof _d.default !== "undefined") _d = _d.default;
+      module.exports = Object.assign({}, typeof _m === "object" && _m !== null ? _m : {}, { default: _d, __esModule: true });
+    }
+  });
+
+  // kwirth-globals:@kwirthmagnify/kwirth-common-front
+  var require_kwirth_common_front = __commonJS({
+    "kwirth-globals:@kwirthmagnify/kwirth-common-front"(exports, module) {
+      var _m = window.__kwirth__.kwirthCommonFront;
+      var _d = _m != null && "default" in Object(_m) ? _m.default : _m;
+      if (typeof _d !== "function" && _d != null && typeof _d.default !== "undefined") _d = _d.default;
+      module.exports = Object.assign({}, typeof _m === "object" && _m !== null ? _m : {}, { default: _d, __esModule: true });
+    }
+  });
+
+  // kwirth-globals:@mui/material
+  var require_material = __commonJS({
+    "kwirth-globals:@mui/material"(exports, module) {
+      var _m = window.__kwirth__.MUI.material;
+      var _d = _m != null && "default" in Object(_m) ? _m.default : _m;
+      if (typeof _d !== "function" && _d != null && typeof _d.default !== "undefined") _d = _d.default;
+      module.exports = Object.assign({}, typeof _m === "object" && _m !== null ? _m : {}, { default: _d, __esModule: true });
+    }
+  });
+
+  // kwirth-globals:@kwirthmagnify/kwirth-common-front/icons
+  var require_icons = __commonJS({
+    "kwirth-globals:@kwirthmagnify/kwirth-common-front/icons"(exports, module) {
+      var _m = window.__kwirth__.MUI.icons;
+      var _d = _m != null && "default" in Object(_m) ? _m.default : _m;
+      if (typeof _d !== "function" && _d != null && typeof _d.default !== "undefined") _d = _d.default;
+      module.exports = Object.assign({}, typeof _m === "object" && _m !== null ? _m : {}, { default: _d, __esModule: true });
+    }
+  });
+
+  // src/front/StatusChannel.ts
+  var import_react3 = __toESM(require_react(), 1);
+  var import_kwirth_common2 = __toESM(require_kwirth_common(), 1);
+  var import_kwirth_common_front = __toESM(require_kwirth_common_front(), 1);
+
+  // src/front/icons.tsx
+  var import_react = __toESM(require_react(), 1);
+  var import_material = __toESM(require_material(), 1);
+  var StatusIcon = (props) => /* @__PURE__ */ import_react.default.createElement(import_material.SvgIcon, { ...props, viewBox: "0 0 24 24" }, /* @__PURE__ */ import_react.default.createElement("g", { fill: "none", stroke: "currentColor", strokeWidth: "1.8", strokeLinecap: "round", strokeLinejoin: "round" }, /* @__PURE__ */ import_react.default.createElement("rect", { x: "2.6", y: "4.6", width: "18.8", height: "14.8", rx: "2.2" }), /* @__PURE__ */ import_react.default.createElement("path", { d: "M6 12h2.6l1.5-3.4 2.6 6.8 1.5-3.4H18" })));
+
+  // src/front/StatusData.ts
+  var StatusData = class {
+    constructor() {
+      this.signals = [];
+      this.configAccepted = false;
+      this.started = false;
+    }
+  };
+
+  // src/front/StatusTabContent.tsx
+  var import_react2 = __toESM(require_react(), 1);
+  var import_material2 = __toESM(require_material(), 1);
+  var import_icons = __toESM(require_icons(), 1);
+  var import_kwirth_common = __toESM(require_kwirth_common(), 1);
+  var HEALTH_LABEL = {
+    ["instantiated" /* INSTANTIATED */]: { label: "Running", color: "success" },
+    ["not-instantiated" /* NOT_INSTANTIATED */]: { label: "Not started", color: "warning" },
+    ["pending-restart" /* PENDING_RESTART */]: { label: "Needs restart", color: "warning" },
+    ["failed" /* FAILED */]: { label: "Failed", color: "error" },
+    ["unknown" /* UNKNOWN */]: { label: "Not reported", color: "default" }
+  };
+  var KIND_LABEL = {
+    ["provider" /* PROVIDER */]: "Provider",
+    ["pluvider" /* PLUVIDER */]: "Pluvider",
+    ["sender" /* SENDER */]: "Sender",
+    ["webhook" /* WEBHOOK */]: "Webhook",
+    ["channel" /* CHANNEL */]: "Channel"
+  };
+  var StatusTabContent = (props) => {
+    const data = props.channelObject.data;
+    const [filter, setFilter] = import_react2.default.useState("");
+    const boxRef = import_react2.default.useRef(null);
+    const [boxTop, setBoxTop] = import_react2.default.useState(0);
+    import_react2.default.useEffect(() => {
+      if (boxRef.current) setBoxTop(boxRef.current.getBoundingClientRect().top);
+    });
+    const refresh = () => {
+      props.channelObject.webSocket?.send(JSON.stringify({
+        msgtype: "statusmessage",
+        channel: "status",
+        action: import_kwirth_common.EInstanceMessageAction.COMMAND,
+        flow: import_kwirth_common.EInstanceMessageFlow.REQUEST,
+        type: import_kwirth_common.EInstanceMessageType.DATA,
+        accessKey: props.channelObject.accessString,
+        instance: props.channelObject.instanceId,
+        command: "refresh" /* REFRESH */
+      }));
+    };
+    const inventory = data.inventory;
+    const componentes = (inventory?.components ?? []).filter((c) => {
+      if (!filter) return true;
+      const f = filter.toLowerCase();
+      return c.id.toLowerCase().includes(f) || KIND_LABEL[c.kind].toLowerCase().includes(f);
+    });
+    const ORDEN = [
+      "failed" /* FAILED */,
+      "pending-restart" /* PENDING_RESTART */,
+      "not-instantiated" /* NOT_INSTANTIATED */,
+      "unknown" /* UNKNOWN */,
+      "instantiated" /* INSTANTIATED */
+    ];
+    componentes.sort((a, b) => {
+      const d = ORDEN.indexOf(a.health) - ORDEN.indexOf(b.health);
+      if (d !== 0) return d;
+      return a.kind === b.kind ? a.id.localeCompare(b.id) : a.kind.localeCompare(b.kind);
+    });
+    const fila = (c) => {
+      const estado = HEALTH_LABEL[c.health];
+      return /* @__PURE__ */ import_react2.default.createElement(import_material2.TableRow, { key: `${c.kind}-${c.id}` }, /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, { sx: { whiteSpace: "nowrap" } }, KIND_LABEL[c.kind]), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { variant: "body2", sx: { fontWeight: 500 } }, c.displayName)), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, /* @__PURE__ */ import_react2.default.createElement(import_material2.Chip, { size: "small", label: estado.label, color: estado.color, variant: c.health === "instantiated" /* INSTANTIATED */ ? "outlined" : "filled" })), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { variant: "body2", color: "text.secondary" }, c.reason ?? "")));
+    };
+    if (!inventory) {
+      return /* @__PURE__ */ import_react2.default.createElement(import_material2.Box, { sx: { p: 2 } }, /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { variant: "body2", color: "text.secondary" }, "Waiting for the inventory\u2026"));
+    }
+    return /* @__PURE__ */ import_react2.default.createElement(import_material2.Box, { sx: { p: 2, display: "flex", flexDirection: "column", minHeight: 0 } }, /* @__PURE__ */ import_react2.default.createElement(import_material2.Stack, { direction: "row", alignItems: "center", spacing: 1, sx: { mb: 1 } }, /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { variant: "subtitle2" }, "What this Kwirth has inside"), /* @__PURE__ */ import_react2.default.createElement(import_material2.Chip, { size: "small", variant: "outlined", label: `${inventory.components.length} components` }), /* @__PURE__ */ import_react2.default.createElement(import_material2.Box, { sx: { flexGrow: 1 } }), /* @__PURE__ */ import_react2.default.createElement(import_material2.TextField, { size: "small", placeholder: "Filter\u2026", value: filter, onChange: (e) => setFilter(e.target.value), sx: { width: 220 } }), /* @__PURE__ */ import_react2.default.createElement(import_material2.Tooltip, { title: "Take a new snapshot" }, /* @__PURE__ */ import_react2.default.createElement(import_material2.IconButton, { size: "small", onClick: refresh }, /* @__PURE__ */ import_react2.default.createElement(import_icons.Refresh, { fontSize: "small" })))), /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { variant: "caption", color: "text.secondary", sx: { mb: 1 } }, "Snapshot taken at ", new Date(inventory.takenAt).toLocaleTimeString(), " \u2014 it does not refresh on its own"), /* @__PURE__ */ import_react2.default.createElement(import_material2.Box, { ref: boxRef, sx: { display: "flex", flexDirection: "column", overflowY: "auto", overflowX: "hidden", width: "100%", flexGrow: 1, height: `calc(100vh - ${boxTop}px - 35px)` } }, /* @__PURE__ */ import_react2.default.createElement(import_material2.Table, { size: "small", stickyHeader: true }, /* @__PURE__ */ import_react2.default.createElement(import_material2.TableHead, null, /* @__PURE__ */ import_react2.default.createElement(import_material2.TableRow, null, /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, "Kind"), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, "Name"), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, "State"), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableCell, null, "Why"))), /* @__PURE__ */ import_react2.default.createElement(import_material2.TableBody, null, componentes.map(fila)))), data.signals.length > 0 && /* @__PURE__ */ import_react2.default.createElement(import_material2.Box, { sx: { mt: 1 } }, data.signals.map((s, i) => /* @__PURE__ */ import_react2.default.createElement(import_material2.Typography, { key: i, variant: "caption", color: "error", display: "block" }, s))));
+  };
+
+  // src/front/StatusChannel.ts
+  var StatusSetup = () => import_react3.default.createElement("div", null, "Kwirth Status has nothing to configure: open it and it shows what this Kwirth has inside.");
+  var StatusChannel = class {
+    constructor() {
+      this.setupVisible = false;
+      this.SetupDialog = StatusSetup;
+      this.TabContent = StatusTabContent;
+      this.channelId = "status";
+      this.requirements = {
+        accessString: true,
+        // los comandos viajan con su accessKey o el core los descarta
+        clusterUrl: true,
+        clusterInfo: false,
+        exit: false,
+        frontChannels: false,
+        metrics: false,
+        notifier: true,
+        notifications: true,
+        setup: false,
+        // no hay nada que preguntar antes de arrancar
+        settings: false,
+        palette: false,
+        userSettings: false,
+        webSocket: true,
+        // el refresco se pide por el socket de la instancia
+        backChannels: false
+      };
+    }
+    getScope() {
+      return import_kwirth_common2.EInstanceConfigScope.NONE;
+    }
+    getChannelIcon() {
+      return import_react3.default.createElement(StatusIcon);
+    }
+    getSetupVisibility() {
+      return this.setupVisible;
+    }
+    setSetupVisibility(visibility) {
+      this.setupVisible = visibility;
+    }
+    processChannelMessage(channelObject, wsEvent) {
+      const msg = JSON.parse(wsEvent.data);
+      const data = channelObject.data;
+      switch (msg.type) {
+        case import_kwirth_common2.EInstanceMessageType.DATA:
+          if (msg.payloadType === "inventory" /* INVENTORY */ && msg.inventory) {
+            data.inventory = msg.inventory;
+          }
+          return { action: import_kwirth_common_front.EChannelRefreshAction.REFRESH };
+        case import_kwirth_common2.EInstanceMessageType.SIGNAL: {
+          const signalMessage = JSON.parse(wsEvent.data);
+          if (signalMessage.flow === import_kwirth_common2.EInstanceMessageFlow.RESPONSE && signalMessage.action === import_kwirth_common2.EInstanceMessageAction.START) {
+            channelObject.instanceId = signalMessage.instance;
+            data.configAccepted = true;
+            data.started = true;
+          }
+          if (signalMessage.level === import_kwirth_common2.ESignalMessageLevel.ERROR) data.signals.push(signalMessage.text ?? "Unknown error");
+          return { action: import_kwirth_common_front.EChannelRefreshAction.REFRESH };
+        }
+        default:
+          return { action: import_kwirth_common_front.EChannelRefreshAction.NONE };
+      }
+    }
+    async initChannel(channelObject) {
+      channelObject.data = new StatusData();
+      return true;
+    }
+    startChannel(_channelObject) {
+      return true;
+    }
+    stopChannel(_channelObject) {
+      return true;
+    }
+    pauseChannel(_channelObject) {
+      return true;
+    }
+    continueChannel(_channelObject) {
+      return true;
+    }
+    socketDisconnected(_channelObject) {
+      return true;
+    }
+    /*
+        false = el core rehace la instancia al reconectar, en vez de dar por buena la anterior. Es lo que
+        queremos: tras una reconexion la foto que hubiera en pantalla puede ser vieja, y se pide otra.
+    */
+    socketReconnect(_channelObject) {
+      return false;
+    }
+  };
+
+  // src/front/index.ts
+  window.__kwirth_plugins__ = window.__kwirth_plugins__ || {};
+  window.__kwirth_plugins__["status"] = StatusChannel;
+})();

package/package.json

@@ -0,0 +1,12 @@
+{
+  "type": "commonjs",
+  "extensionType": "plugin",
+  "id": "status",
+  "name": "@kwirthmagnify/kwirth-plugin-status",
+  "displayName": "Kwirth Status",
+  "version": "0.1.0",
+  "description": "A look inside Kwirth: what is installed, how it is doing and who consumes what",
+  "icon": "<svg viewBox='0 0 24 24'><g fill='none' stroke='currentColor' stroke-width='1.8' stroke-linecap='round' stroke-linejoin='round'><rect x='2.6' y='4.6' width='18.8' height='14.8' rx='2.2'/><path d='M6 12h2.6l1.5-3.4 2.6 6.8 1.5-3.4H18'/></g></svg>",
+  "requiresRestart": false,
+  "requiresExtension": []
+}