@surething/cockpit 1.0.204 → 1.0.206

package/dist/JupyterKernelManager-VBKKSRVJ.mjs

@@ -1,269 +0,0 @@
-// src/lib/bubbles/jupyter/JupyterKernelManager.ts
-import { spawn } from "child_process";
-import { join } from "path";
-import { homedir } from "os";
-import { existsSync } from "fs";
-import { createInterface } from "readline";
-var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("jupyter_kernel_manager");
-var IDLE_TIMEOUT = 10 * 60 * 1e3;
-var IDLE_CHECK_INTERVAL = 60 * 1e3;
-var JupyterKernelManager = class {
-  constructor() {
-    this.instances = /* @__PURE__ */ new Map();
-    this.idleTimer = null;
-    process.on("exit", () => {
-      this.shutdownAll();
-    });
-  }
-  /**
-   * Find python3 executable
-   */
-  findPython() {
-    return "python3";
-  }
-  /**
-   * Resolve jupyter_bridge.py path.
-   * Production: ~/.cockpit/kernels/jupyter_bridge.py (copied by postinstall)
-   * Dev: COCKPIT_ROOT/kernels/jupyter_bridge.py or legacy src path
-   */
-  resolveBridgePath() {
-    const installedPath = join(homedir(), ".cockpit", "kernels", "jupyter_bridge.py");
-    if (existsSync(installedPath)) {
-      return installedPath;
-    }
-    const root = process.env.COCKPIT_ROOT;
-    if (root) {
-      const devPath = join(root, "kernels", "jupyter_bridge.py");
-      if (existsSync(devPath)) {
-        return devPath;
-      }
-    }
-    return join(__dirname, "jupyter_bridge.py");
-  }
-  /**
-   * Get or create a kernel for a bubble
-   */
-  async getOrCreate(bubbleId, cwd) {
-    const existing = this.instances.get(bubbleId);
-    if (existing) {
-      existing.lastUsedAt = Date.now();
-      await existing.readyPromise;
-      return existing;
-    }
-    const python = this.findPython();
-    const bridgePath = this.resolveBridgePath();
-    const bridge = spawn(python, ["-u", bridgePath], {
-      cwd,
-      env: {
-        ...process.env,
-        JUPYTER_CWD: cwd,
-        PYTHONUNBUFFERED: "1"
-      },
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const readline = createInterface({ input: bridge.stdout });
-    let resolveReady;
-    let rejectReady;
-    const readyPromise = new Promise((resolve, reject) => {
-      resolveReady = resolve;
-      rejectReady = reject;
-    });
-    const instance = {
-      bubbleId,
-      cwd,
-      bridge,
-      readline,
-      ready: false,
-      readyPromise,
-      lastUsedAt: Date.now(),
-      outputListeners: /* @__PURE__ */ new Set()
-    };
-    this.instances.set(bubbleId, instance);
-    readline.on("line", (line) => {
-      let msg;
-      try {
-        msg = JSON.parse(line);
-      } catch {
-        return;
-      }
-      const type = msg.type;
-      if (type === "ready") {
-        instance.ready = true;
-        resolveReady();
-      } else if (type === "error") {
-        const errorMsg = msg.message;
-        instance.errorMessage = errorMsg;
-        console.error(`[jupyter-kernel] ${bubbleId}: ${errorMsg}`);
-        if (!instance.ready) {
-          rejectReady(new Error(errorMsg));
-        }
-        const output = {
-          msg_id: "",
-          msg_type: "kernel_error",
-          content: { message: errorMsg }
-        };
-        for (const listener of instance.outputListeners) {
-          listener(output);
-        }
-      } else if (msg.msg_id !== void 0) {
-        const output = {
-          msg_id: msg.msg_id,
-          msg_type: msg.msg_type,
-          content: msg.content
-        };
-        for (const listener of instance.outputListeners) {
-          listener(output);
-        }
-      }
-    });
-    bridge.stderr?.on("data", (data) => {
-      const text = data.toString().trim();
-      if (text) {
-        console.error(`[jupyter-kernel] ${bubbleId} stderr: ${text}`);
-      }
-    });
-    bridge.on("exit", (code) => {
-      console.log(`[jupyter-kernel] ${bubbleId} bridge exited with code ${code}`);
-      readline.close();
-      this.instances.delete(bubbleId);
-      if (!instance.ready) {
-        rejectReady(new Error(`Bridge exited with code ${code}`));
-      }
-      const output = {
-        msg_id: "",
-        msg_type: "kernel_died",
-        content: { exit_code: code }
-      };
-      for (const listener of instance.outputListeners) {
-        listener(output);
-      }
-    });
-    bridge.on("error", (err) => {
-      console.error(`[jupyter-kernel] ${bubbleId} spawn error:`, err.message);
-      instance.errorMessage = err.message.includes("ENOENT") ? "Python not found. Ensure python3 is installed and in PATH." : err.message;
-      if (!instance.ready) {
-        rejectReady(new Error(instance.errorMessage));
-      }
-    });
-    this.startIdleTimer();
-    try {
-      await readyPromise;
-    } catch {
-    }
-    return instance;
-  }
-  /**
-   * Execute code in a kernel
-   */
-  async execute(bubbleId, code, msgId, cwd) {
-    let instance = this.instances.get(bubbleId);
-    if (!instance) {
-      if (!cwd) throw new Error("Kernel not found and no cwd provided");
-      instance = await this.getOrCreate(bubbleId, cwd);
-    }
-    if (!instance.ready) {
-      throw new Error(instance.errorMessage || "Kernel not ready");
-    }
-    instance.lastUsedAt = Date.now();
-    const cmd = JSON.stringify({ cmd: "execute", msg_id: msgId, code });
-    instance.bridge.stdin.write(cmd + "\n");
-  }
-  /**
-   * Interrupt the kernel
-   */
-  async interrupt(bubbleId) {
-    const instance = this.instances.get(bubbleId);
-    if (!instance || !instance.ready) return;
-    const cmd = JSON.stringify({ cmd: "interrupt" });
-    instance.bridge.stdin.write(cmd + "\n");
-  }
-  /**
-   * Shutdown a kernel
-   */
-  async shutdown(bubbleId) {
-    const instance = this.instances.get(bubbleId);
-    if (!instance) return;
-    try {
-      if (instance.bridge.stdin?.writable) {
-        instance.bridge.stdin.write(JSON.stringify({ cmd: "shutdown" }) + "\n");
-      }
-    } catch {
-    }
-    setTimeout(() => {
-      try {
-        instance.bridge.kill("SIGKILL");
-      } catch {
-      }
-    }, 3e3);
-    instance.readline.close();
-    this.instances.delete(bubbleId);
-    if (this.instances.size === 0) {
-      this.stopIdleTimer();
-    }
-  }
-  /**
-   * Shutdown all kernels
-   */
-  shutdownAll() {
-    for (const [id] of this.instances) {
-      this.shutdown(id);
-    }
-    this.stopIdleTimer();
-  }
-  /**
-   * Subscribe to kernel output messages
-   */
-  addOutputListener(bubbleId, listener) {
-    const instance = this.instances.get(bubbleId);
-    if (!instance) return () => {
-    };
-    instance.outputListeners.add(listener);
-    return () => {
-      instance.outputListeners.delete(listener);
-    };
-  }
-  /**
-   * Check if a kernel exists for a bubble
-   */
-  has(bubbleId) {
-    return this.instances.has(bubbleId);
-  }
-  /**
-   * Get kernel error message if any
-   */
-  getError(bubbleId) {
-    return this.instances.get(bubbleId)?.errorMessage;
-  }
-  // ============================================
-  // Idle timeout
-  // ============================================
-  startIdleTimer() {
-    if (this.idleTimer) return;
-    this.idleTimer = setInterval(() => {
-      const now = Date.now();
-      for (const [id, instance] of this.instances) {
-        if (now - instance.lastUsedAt > IDLE_TIMEOUT) {
-          console.log(`[jupyter-kernel] idle timeout: ${id}`);
-          this.shutdown(id);
-        }
-      }
-      if (this.instances.size === 0) {
-        this.stopIdleTimer();
-      }
-    }, IDLE_CHECK_INTERVAL);
-    if (typeof this.idleTimer.unref === "function") {
-      this.idleTimer.unref();
-    }
-  }
-  stopIdleTimer() {
-    if (this.idleTimer) {
-      clearInterval(this.idleTimer);
-      this.idleTimer = null;
-    }
-  }
-};
-var g = globalThis;
-var kernelManager = g[GLOBAL_KEY] ?? (g[GLOBAL_KEY] = new JupyterKernelManager());
-export {
-  kernelManager
-};