@decido/shell 4.0.2 → 4.0.3

package/dist/DebugPanel-KEKDMHDN.mjs

@@ -0,0 +1,14 @@
+import {
+  DebugPanel
+} from "./chunk-VBPGEFNM.mjs";
+import "./chunk-JF5QSJYT.mjs";
+import "./chunk-ZCCCBHE6.mjs";
+import "./chunk-UHT6FIYF.mjs";
+import "./chunk-3BZX7LF2.mjs";
+import "./chunk-MSVEFEXE.mjs";
+import "./chunk-3P4P3M54.mjs";
+import "./chunk-XMSU6UWD.mjs";
+import "./chunk-UJCSKKID.mjs";
+export {
+  DebugPanel
+};

package/dist/MorphShell-FKDBB7E5.mjs

@@ -0,0 +1,14 @@
+import {
+  MorphShell
+} from "./chunk-2YMI4N5I.mjs";
+import "./chunk-IMHORBTL.mjs";
+import "./chunk-JF5QSJYT.mjs";
+import "./chunk-ZCCCBHE6.mjs";
+import "./chunk-UHT6FIYF.mjs";
+import "./chunk-MSVEFEXE.mjs";
+import "./chunk-3P4P3M54.mjs";
+import "./chunk-XMSU6UWD.mjs";
+import "./chunk-UJCSKKID.mjs";
+export {
+  MorphShell
+};

package/dist/PlaygroundAppSidebar-ALYJJGAO.mjs

@@ -0,0 +1,9 @@
+import {
+  PlaygroundAppSidebar
+} from "./chunk-RWZ4BOIN.mjs";
+import "./chunk-F3OTFHNO.mjs";
+import "./chunk-XMSU6UWD.mjs";
+import "./chunk-UJCSKKID.mjs";
+export {
+  PlaygroundAppSidebar
+};

package/dist/PlaygroundChat-MI2KXMK6.mjs

@@ -0,0 +1,15 @@
+import {
+  PlaygroundChat
+} from "./chunk-OCHGY2MN.mjs";
+import "./chunk-IMHORBTL.mjs";
+import "./chunk-F3OTFHNO.mjs";
+import "./chunk-QHQW2HMU.mjs";
+import "./chunk-UHT6FIYF.mjs";
+import "./chunk-3BZX7LF2.mjs";
+import "./chunk-MSVEFEXE.mjs";
+import "./chunk-3P4P3M54.mjs";
+import "./chunk-XMSU6UWD.mjs";
+import "./chunk-UJCSKKID.mjs";
+export {
+  PlaygroundChat
+};

package/dist/PlaygroundTerminal-5AV4BJAI.mjs

@@ -0,0 +1,7 @@
+import {
+  PlaygroundTerminal
+} from "./chunk-Q64KZXPK.mjs";
+import "./chunk-UJCSKKID.mjs";
+export {
+  PlaygroundTerminal
+};

package/dist/PluginSandbox-WMNAUQOJ.mjs

@@ -0,0 +1,188 @@
+import "./chunk-UJCSKKID.mjs";
+
+// ../sdk/src/sandbox/PluginSandbox.ts
+import { probe, probeStart } from "@decido/logger";
+var PluginSandbox = class {
+  worker = null;
+  config;
+  pendingRequests = /* @__PURE__ */ new Map();
+  isReady = false;
+  readyPromise;
+  readyResolve;
+  /** Callbacks for host-side handling */
+  onRpcRequest;
+  onWidgetRegister;
+  onLog;
+  onError;
+  constructor(config) {
+    this.config = config;
+    this.readyPromise = new Promise((resolve) => {
+      this.readyResolve = resolve;
+    });
+  }
+  /** Start the sandbox Worker and load the plugin */
+  async start() {
+    const endProbe = probeStart("sandbox.start", { context: { module: "sdk", component: "PluginSandbox" } });
+    if (this.config.trusted) {
+      this.isReady = true;
+      this.readyResolve();
+      endProbe({ pluginId: this.config.pluginId, trusted: true });
+      return;
+    }
+    const workerUrl = new URL("./sandbox-worker.js", import.meta.url);
+    this.worker = new Worker(workerUrl, { type: "module", name: `plugin-${this.config.pluginId}` });
+    this.worker.onmessage = (event) => {
+      this.handleWorkerMessage(event.data);
+    };
+    this.worker.onerror = (event) => {
+      probe("sandbox.error", { pluginId: this.config.pluginId, error: event.message }, { level: "error", context: { module: "sdk", component: "PluginSandbox" } });
+      console.error(`[Sandbox:${this.config.pluginId}] Worker error:`, event.message);
+      if (this.onError) this.onError(event.message);
+    };
+    this.sendToWorker({
+      type: "SANDBOX_INIT",
+      pluginId: this.config.pluginId,
+      payload: {
+        pluginUrl: this.config.pluginUrl,
+        tenantId: this.config.tenantId,
+        permissions: this.config.permissions || []
+      }
+    });
+    const timeout = this.config.timeout || 1e4;
+    await Promise.race([
+      this.readyPromise,
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error(`Plugin "${this.config.pluginId}" sandbox init timed out after ${timeout}ms`)), timeout)
+      )
+    ]);
+    endProbe({ pluginId: this.config.pluginId, trusted: false });
+  }
+  /** Request the plugin to mount */
+  async mount() {
+    if (this.config.trusted) return;
+    this.sendToWorker({
+      type: "SANDBOX_MOUNT",
+      pluginId: this.config.pluginId
+    });
+  }
+  /** Request the plugin to unmount */
+  async unmount() {
+    if (this.config.trusted) return;
+    this.sendToWorker({
+      type: "SANDBOX_UNMOUNT",
+      pluginId: this.config.pluginId
+    });
+  }
+  /** Broadcast an event into the sandbox */
+  broadcastEvent(topic, payload) {
+    if (!this.worker) return;
+    this.sendToWorker({
+      type: "SANDBOX_EVENT_BROADCAST",
+      pluginId: this.config.pluginId,
+      payload: { topic, data: payload }
+    });
+  }
+  /** Destroy the sandbox — terminates the Worker */
+  destroy() {
+    probe("sandbox.destroy", { pluginId: this.config.pluginId, pendingRequests: this.pendingRequests.size }, { context: { module: "sdk", component: "PluginSandbox" } });
+    if (this.worker) {
+      this.sendToWorker({
+        type: "SANDBOX_DESTROY",
+        pluginId: this.config.pluginId
+      });
+      setTimeout(() => {
+        this.worker?.terminate();
+        this.worker = null;
+      }, 500);
+    }
+    for (const [, pending] of this.pendingRequests) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("Sandbox destroyed"));
+    }
+    this.pendingRequests.clear();
+  }
+  // ── Internal ──
+  sendToWorker(message) {
+    this.worker?.postMessage(message);
+  }
+  handleWorkerMessage(msg) {
+    switch (msg.type) {
+      case "SANDBOX_READY":
+        this.isReady = true;
+        this.readyResolve();
+        break;
+      case "SANDBOX_RPC_REQUEST":
+        probe("sandbox.rpc.request", { pluginId: msg.pluginId, action: msg.payload?.action }, { context: { module: "sdk", component: "PluginSandbox" }, security: { tier: 1 } });
+        this.handleRpcFromPlugin(msg);
+        break;
+      case "SANDBOX_RPC_RESPONSE":
+        this.handleRpcResponse(msg);
+        break;
+      case "SANDBOX_EVENT_EMIT":
+        break;
+      case "SANDBOX_WIDGET_REGISTER":
+        if (this.onWidgetRegister) {
+          this.onWidgetRegister(msg.payload);
+        }
+        break;
+      case "SANDBOX_LOG":
+        if (this.onLog) {
+          this.onLog(msg.payload?.level || "log", msg.payload?.args || []);
+        } else {
+          const level = msg.payload?.level || "log";
+          const prefix = `[Sandbox:${msg.pluginId}]`;
+          console[level]?.(prefix, ...msg.payload?.args || []);
+        }
+        break;
+      case "SANDBOX_ERROR":
+        console.error(`[Sandbox:${msg.pluginId}] Error:`, msg.error);
+        if (this.onError) this.onError(msg.error || "Unknown error");
+        break;
+      default:
+        console.warn(`[Sandbox:${msg.pluginId}] Unknown message type: ${msg.type}`);
+    }
+  }
+  async handleRpcFromPlugin(msg) {
+    if (!msg.requestId || !this.onRpcRequest) {
+      this.sendToWorker({
+        type: "SANDBOX_RPC_RESPONSE",
+        pluginId: msg.pluginId,
+        requestId: msg.requestId,
+        error: "No RPC handler available"
+      });
+      return;
+    }
+    try {
+      const result = await this.onRpcRequest(msg.payload?.action, msg.payload?.data);
+      this.sendToWorker({
+        type: "SANDBOX_RPC_RESPONSE",
+        pluginId: msg.pluginId,
+        requestId: msg.requestId,
+        payload: result
+      });
+    } catch (error) {
+      this.sendToWorker({
+        type: "SANDBOX_RPC_RESPONSE",
+        pluginId: msg.pluginId,
+        requestId: msg.requestId,
+        error: error.message
+      });
+    }
+  }
+  handleRpcResponse(msg) {
+    const requestId = msg.requestId;
+    if (!requestId) return;
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    clearTimeout(pending.timer);
+    this.pendingRequests.delete(requestId);
+    if (msg.error) {
+      pending.reject(new Error(msg.error));
+    } else {
+      pending.resolve(msg.payload);
+    }
+  }
+};
+export {
+  PluginSandbox
+};