@surething/cockpit 1.0.175

package/dist/wsServer.mjs

@@ -0,0 +1,1441 @@
+import {
+  GLOBAL_STATE_FILE,
+  REVIEW_DIR,
+  REVIEW_SIGNAL_FILE,
+  ensureParentDir,
+  getLastUserMessage,
+  getTerminalHistoryPath,
+  getTerminalOutputPath,
+  readJsonFile
+} from "./chunk-OER3N6H7.mjs";
+
+// src/lib/wsServer.ts
+import { WebSocketServer, WebSocket as WebSocket2 } from "ws";
+import { parse } from "url";
+import { watch as watch2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname } from "path";
+import { spawn, execSync } from "child_process";
+import * as nodePty from "node-pty";
+
+// src/lib/fileWatcher.ts
+import { watch, readFileSync, statSync, existsSync, mkdirSync, writeFileSync } from "fs";
+import { join, resolve } from "path";
+var GIT_WATCH_FILES = [
+  ".git/HEAD",
+  // Do not watch .git/index: git status refreshes its stat cache, causing a feedback loop.
+  // commit/checkout/merge all modify HEAD or refs simultaneously; index is not needed.
+  ".git/MERGE_HEAD",
+  ".git/REBASE_HEAD"
+];
+var GIT_WATCH_DIRS = [
+  ".git/refs"
+];
+var DEBOUNCE_MS = 500;
+var THROTTLE_MS = 3e3;
+function resolveGitDir(cwd) {
+  const dotGit = join(cwd, ".git");
+  try {
+    const stat = statSync(dotGit);
+    if (stat.isDirectory()) {
+      return dotGit;
+    }
+    const content = readFileSync(dotGit, "utf-8").trim();
+    const match = content.match(/^gitdir:\s*(.+)$/);
+    if (match) {
+      return resolve(cwd, match[1]);
+    }
+  } catch {
+  }
+  return dotGit;
+}
+var FileWatcherManager = class {
+  constructor() {
+    this.watchers = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Subscribe to file change events for a given cwd.
+   * @returns unsubscribe function
+   */
+  subscribe(cwd, callback) {
+    let entry = this.watchers.get(cwd);
+    if (!entry) {
+      entry = this.createWatcher(cwd);
+      this.watchers.set(cwd, entry);
+    }
+    entry.listeners.add(callback);
+    return () => {
+      this.unsubscribe(cwd, callback);
+    };
+  }
+  unsubscribe(cwd, callback) {
+    const entry = this.watchers.get(cwd);
+    if (!entry) return;
+    entry.listeners.delete(callback);
+    if (entry.listeners.size === 0) {
+      if (entry.debounceTimer) clearTimeout(entry.debounceTimer);
+      if (entry.throttleTimer) clearTimeout(entry.throttleTimer);
+      if (entry.cwdRestartTimer) clearTimeout(entry.cwdRestartTimer);
+      for (const w of entry.watchers) {
+        try {
+          w.close();
+        } catch {
+        }
+      }
+      this.watchers.delete(cwd);
+    }
+  }
+  createWatcher(cwd) {
+    const entry = {
+      watchers: [],
+      listeners: /* @__PURE__ */ new Set(),
+      pendingEvents: [],
+      debounceTimer: null,
+      throttleTimer: null,
+      cwdRestartTimer: null
+    };
+    const pushEvent = (event) => {
+      if (!entry.pendingEvents.some((e) => e.type === event.type)) {
+        entry.pendingEvents.push(event);
+      }
+      if (entry.debounceTimer) clearTimeout(entry.debounceTimer);
+      entry.debounceTimer = setTimeout(() => {
+        this.flush(entry);
+      }, DEBOUNCE_MS);
+      if (!entry.throttleTimer) {
+        entry.throttleTimer = setTimeout(() => {
+          this.flush(entry);
+        }, THROTTLE_MS);
+      }
+    };
+    const startCwdWatcher = () => {
+      try {
+        const cwdWatcher = watch(cwd, { recursive: true }, (_eventType, filename) => {
+          if (!filename) return;
+          if (filename.startsWith(".next/") || filename.startsWith("node_modules/")) return;
+          if (filename.startsWith(".git/")) {
+            if (filename === ".git/HEAD" || filename.startsWith(".git/refs/")) {
+              pushEvent({ type: "git" });
+            }
+            return;
+          }
+          pushEvent({ type: "file" });
+        });
+        cwdWatcher.on("error", (err) => {
+          console.error(`File watcher error for ${cwd}:`, err);
+          const idx = entry.watchers.indexOf(cwdWatcher);
+          if (idx !== -1) entry.watchers.splice(idx, 1);
+          try {
+            cwdWatcher.close();
+          } catch {
+          }
+          if (entry.listeners.size > 0 && !entry.cwdRestartTimer) {
+            entry.cwdRestartTimer = setTimeout(() => {
+              entry.cwdRestartTimer = null;
+              if (entry.listeners.size > 0) startCwdWatcher();
+            }, 2e3);
+          }
+        });
+        entry.watchers.push(cwdWatcher);
+      } catch (err) {
+        console.error(`Failed to watch ${cwd}:`, err);
+      }
+    };
+    startCwdWatcher();
+    const gitDir = resolveGitDir(cwd);
+    const watchGitFile = (filePath) => {
+      try {
+        const w = watch(filePath, () => {
+          pushEvent({ type: "git" });
+          try {
+            w.close();
+          } catch {
+          }
+          const idx = entry.watchers.indexOf(w);
+          if (idx !== -1) entry.watchers.splice(idx, 1);
+          if (entry.listeners.size > 0) {
+            setTimeout(() => watchGitFile(filePath), 50);
+          }
+        });
+        w.on("error", () => {
+          const idx = entry.watchers.indexOf(w);
+          if (idx !== -1) entry.watchers.splice(idx, 1);
+          if (entry.listeners.size > 0 && existsSync(filePath)) {
+            setTimeout(() => watchGitFile(filePath), 500);
+          }
+        });
+        entry.watchers.push(w);
+      } catch {
+      }
+    };
+    for (const gitFile of GIT_WATCH_FILES) {
+      const filename = gitFile.replace(".git/", "");
+      watchGitFile(join(gitDir, filename));
+    }
+    for (const gitDirName of GIT_WATCH_DIRS) {
+      const dirName = gitDirName.replace(".git/", "");
+      try {
+        const w = watch(join(gitDir, dirName), { recursive: true }, () => {
+          pushEvent({ type: "git" });
+        });
+        w.on("error", () => {
+        });
+        entry.watchers.push(w);
+      } catch {
+      }
+    }
+    return entry;
+  }
+  flush(entry) {
+    if (entry.debounceTimer) {
+      clearTimeout(entry.debounceTimer);
+      entry.debounceTimer = null;
+    }
+    if (entry.throttleTimer) {
+      clearTimeout(entry.throttleTimer);
+      entry.throttleTimer = null;
+    }
+    if (entry.pendingEvents.length === 0) return;
+    const events = [...entry.pendingEvents];
+    entry.pendingEvents = [];
+    for (const callback of entry.listeners) {
+      try {
+        callback(events);
+      } catch (err) {
+        console.error("File watcher callback error:", err);
+      }
+    }
+  }
+};
+var ReviewWatcher = class {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Set();
+    this.watcher = null;
+    this.debounceTimer = null;
+  }
+  subscribe(callback) {
+    this.listeners.add(callback);
+    if (!this.watcher) this.start();
+    return () => {
+      this.listeners.delete(callback);
+      if (this.listeners.size === 0) this.stop();
+    };
+  }
+  start() {
+    try {
+      if (!existsSync(REVIEW_DIR)) mkdirSync(REVIEW_DIR, { recursive: true });
+      if (!existsSync(REVIEW_SIGNAL_FILE)) writeFileSync(REVIEW_SIGNAL_FILE, "0");
+      this.watcher = watch(REVIEW_SIGNAL_FILE, () => {
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => this.notify(), 300);
+      });
+      this.watcher.on("error", () => {
+        this.stop();
+        setTimeout(() => {
+          if (this.listeners.size > 0) this.start();
+        }, 2e3);
+      });
+    } catch {
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      try {
+        this.watcher.close();
+      } catch {
+      }
+      this.watcher = null;
+    }
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer);
+      this.debounceTimer = null;
+    }
+  }
+  notify() {
+    for (const cb of this.listeners) {
+      try {
+        cb();
+      } catch (err) {
+        console.error("ReviewWatcher callback error:", err);
+      }
+    }
+  }
+};
+var fileWatcher = new FileWatcherManager();
+var reviewWatcher = new ReviewWatcher();
+
+// src/lib/wsServer.ts
+import { readFile } from "fs/promises";
+
+// src/lib/terminal/RunningCommandRegistry.ts
+import fs from "fs/promises";
+
+// src/lib/shortId.ts
+function crc32(str) {
+  let crc = 4294967295;
+  for (let i = 0; i < str.length; i++) {
+    crc ^= str.charCodeAt(i);
+    for (let j = 0; j < 8; j++) {
+      crc = crc >>> 1 ^ (crc & 1 ? 3988292384 : 0);
+    }
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+function toShortId(fullId) {
+  const hash = crc32(fullId);
+  let id = "";
+  let val = hash;
+  for (let i = 0; i < 4; i++) {
+    id += String.fromCharCode(97 + val % 26);
+    val = Math.floor(val / 26);
+  }
+  return id;
+}
+
+// src/lib/terminal/TerminalBridge.ts
+var REGISTRY_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_registry");
+var REVERSE_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_reverse");
+var OUTPUT_LISTENERS_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_output_listeners");
+var EXIT_LISTENERS_KEY = /* @__PURE__ */ Symbol.for("terminal_bridge_exit_listeners");
+function getRegistry() {
+  const g = globalThis;
+  if (!g[REGISTRY_KEY]) g[REGISTRY_KEY] = /* @__PURE__ */ new Map();
+  return g[REGISTRY_KEY];
+}
+function getReverseIndex() {
+  const g = globalThis;
+  if (!g[REVERSE_KEY]) g[REVERSE_KEY] = /* @__PURE__ */ new Map();
+  return g[REVERSE_KEY];
+}
+function getOutputListeners() {
+  const g = globalThis;
+  if (!g[OUTPUT_LISTENERS_KEY]) g[OUTPUT_LISTENERS_KEY] = /* @__PURE__ */ new Map();
+  return g[OUTPUT_LISTENERS_KEY];
+}
+function getExitListeners() {
+  const g = globalThis;
+  if (!g[EXIT_LISTENERS_KEY]) g[EXIT_LISTENERS_KEY] = /* @__PURE__ */ new Map();
+  return g[EXIT_LISTENERS_KEY];
+}
+function registerTerminal(tabId, commandId, command, projectCwd) {
+  const fullId = tabId + commandId;
+  const shortId = toShortId(fullId);
+  getRegistry().set(shortId, { shortId, commandId, tabId, command, projectCwd, registeredAt: Date.now() });
+  getReverseIndex().set(commandId, shortId);
+  return shortId;
+}
+function finalizeTerminal(commandId, exitCode) {
+  const shortId = getReverseIndex().get(commandId);
+  if (shortId) {
+    const entry = getRegistry().get(shortId);
+    if (entry) {
+      entry.exitCode = exitCode;
+    }
+    getOutputListeners().delete(commandId);
+    getExitListeners().delete(commandId);
+  }
+}
+function unregisterTerminal(commandId) {
+  const shortId = getReverseIndex().get(commandId);
+  if (shortId) {
+    getRegistry().delete(shortId);
+    getReverseIndex().delete(commandId);
+    getOutputListeners().delete(commandId);
+    getExitListeners().delete(commandId);
+  }
+}
+function getTerminalByShortId(shortId) {
+  return getRegistry().get(shortId);
+}
+function listTerminals(getRunning) {
+  const result = [];
+  for (const [, entry] of getRegistry()) {
+    const cmd = getRunning?.(entry.commandId);
+    result.push({
+      shortId: entry.shortId,
+      commandId: entry.commandId,
+      tabId: entry.tabId,
+      command: entry.command,
+      pid: cmd?.pid ?? 0,
+      running: !!cmd
+    });
+  }
+  return result;
+}
+function addOutputListener(commandId, cb) {
+  const listeners = getOutputListeners();
+  if (!listeners.has(commandId)) listeners.set(commandId, /* @__PURE__ */ new Set());
+  listeners.get(commandId).add(cb);
+  return () => {
+    listeners.get(commandId)?.delete(cb);
+    if (listeners.get(commandId)?.size === 0) listeners.delete(commandId);
+  };
+}
+function notifyOutputListeners(commandId, data) {
+  const cbs = getOutputListeners().get(commandId);
+  if (cbs) {
+    for (const cb of cbs) cb(data);
+  }
+}
+function addExitListener(commandId, cb) {
+  const listeners = getExitListeners();
+  if (!listeners.has(commandId)) listeners.set(commandId, /* @__PURE__ */ new Set());
+  listeners.get(commandId).add(cb);
+  return () => {
+    listeners.get(commandId)?.delete(cb);
+    if (listeners.get(commandId)?.size === 0) listeners.delete(commandId);
+  };
+}
+function notifyExitListeners(commandId, exitCode) {
+  const cbs = getExitListeners().get(commandId);
+  if (cbs) {
+    for (const cb of cbs) cb(exitCode);
+  }
+}
+
+// src/lib/terminal/RunningCommandRegistry.ts
+var MAX_OUTPUT_LINES = 5e3;
+var OUTPUT_FILE_THRESHOLD = 4096;
+var MAX_PARTIAL_BYTES = 64 * 1024;
+var GLOBAL_KEY = /* @__PURE__ */ Symbol.for("terminal_running_commands");
+var SERVER_ID_KEY = /* @__PURE__ */ Symbol.for("terminal_server_id");
+function getServerId() {
+  const g = globalThis;
+  if (!g[SERVER_ID_KEY]) {
+    g[SERVER_ID_KEY] = `srv_${Date.now()}_${process.pid}`;
+    console.log(`[registry] server started, id=${g[SERVER_ID_KEY]}, pid=${process.pid}`);
+  }
+  return g[SERVER_ID_KEY];
+}
+getServerId();
+function getRegistry2() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = /* @__PURE__ */ new Map();
+  }
+  return g[GLOBAL_KEY];
+}
+function registerCommand(cmd) {
+  console.log(`[registry] register: id=${cmd.commandId}, cmd="${cmd.command}", pid=${cmd.pid}, pty=${!!cmd.ptyProcess}, server=${getServerId()}`);
+  getRegistry2().set(cmd.commandId, {
+    ...cmd,
+    outputLines: [],
+    outputPartial: ""
+  });
+  registerTerminal(cmd.tabId, cmd.commandId, cmd.command, cmd.projectCwd);
+  writeHistoryPlaceholder(cmd.commandId, cmd.command, cmd.timestamp, cmd.cwd, cmd.projectCwd, cmd.tabId, !!cmd.usePty).catch(() => {
+  });
+  if (cmd.ptyProcess) {
+    const pty = cmd.ptyProcess;
+    pty.onData((data) => {
+      appendCommandOutput(cmd.commandId, data);
+    });
+    const ptyPid = cmd.pid;
+    pty.onExit(async ({ exitCode }) => {
+      try {
+        await finalizeCommand(cmd.commandId, exitCode, ptyPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+  } else {
+    const child = cmd.process;
+    child.stdout?.on("data", (data) => {
+      appendCommandOutput(cmd.commandId, data.toString());
+    });
+    child.stderr?.on("data", (data) => {
+      appendCommandOutput(cmd.commandId, data.toString());
+    });
+    const childPid = cmd.pid;
+    child.on("close", async (code) => {
+      try {
+        await finalizeCommand(cmd.commandId, code ?? 0, childPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+    child.on("error", async () => {
+      try {
+        await finalizeCommand(cmd.commandId, 1, childPid);
+      } catch (e) {
+        console.error("[registry] finalize error:", e);
+      }
+    });
+  }
+}
+function appendCommandOutput(commandId, data) {
+  const cmd = getRegistry2().get(commandId);
+  if (!cmd) return;
+  const text = cmd.outputPartial + data;
+  const parts = text.split("\n");
+  cmd.outputPartial = parts.pop() || "";
+  if (cmd.outputPartial.length > MAX_PARTIAL_BYTES) {
+    cmd.outputPartial = cmd.outputPartial.slice(-MAX_PARTIAL_BYTES);
+  }
+  if (parts.length > 0) {
+    cmd.outputLines.push(...parts);
+    if (cmd.outputLines.length > MAX_OUTPUT_LINES) {
+      cmd.outputLines.splice(0, cmd.outputLines.length - MAX_OUTPUT_LINES);
+    }
+  }
+  notifyOutputListeners(commandId, data);
+}
+function getBufferedOutput(cmd) {
+  const lines = cmd.outputLines.join("\n");
+  if (cmd.outputPartial) {
+    return lines ? lines + "\n" + cmd.outputPartial : cmd.outputPartial;
+  }
+  return lines;
+}
+function getRunningCommands(projectCwd) {
+  const results = [];
+  for (const cmd of getRegistry2().values()) {
+    if (cmd.projectCwd === projectCwd) {
+      results.push({
+        commandId: cmd.commandId,
+        command: cmd.command,
+        cwd: cmd.cwd,
+        tabId: cmd.tabId,
+        pid: cmd.pid,
+        timestamp: cmd.timestamp,
+        ...cmd.usePty ? { usePty: true } : {}
+      });
+    }
+  }
+  return results;
+}
+function getRunningCommand(commandId) {
+  return getRegistry2().get(commandId);
+}
+function getRegistrySize() {
+  return getRegistry2().size;
+}
+function getAllProjectCwds() {
+  const cwds = /* @__PURE__ */ new Set();
+  for (const cmd of getRegistry2().values()) {
+    cwds.add(cmd.projectCwd);
+  }
+  return [...cwds];
+}
+async function writeHistoryPlaceholder(commandId, command, timestamp, cwd, projectCwd, tabId, usePty) {
+  const historyPath = getTerminalHistoryPath(projectCwd, tabId);
+  await ensureParentDir(historyPath);
+  const entry = {
+    id: commandId,
+    command,
+    output: "",
+    timestamp,
+    cwd,
+    ...usePty ? { usePty: true } : {},
+    running: true
+  };
+  let existingLines = [];
+  try {
+    const content = await fs.readFile(historyPath, "utf-8");
+    existingLines = content.trim().split("\n").filter(Boolean);
+  } catch {
+  }
+  if (existingLines.length >= 100) {
+    const removedLines = existingLines.slice(0, existingLines.length - 99);
+    for (const line of removedLines) {
+      try {
+        const old = JSON.parse(line);
+        if (old.outputFile) await fs.unlink(old.outputFile).catch(() => {
+        });
+      } catch {
+      }
+    }
+    existingLines = existingLines.slice(-99);
+  }
+  existingLines.push(JSON.stringify(entry));
+  await fs.writeFile(historyPath, existingLines.join("\n") + "\n", "utf-8");
+}
+async function finalizeCommand(commandId, exitCode, pid) {
+  const registry2 = getRegistry2();
+  const cmd = registry2.get(commandId);
+  if (!cmd) return;
+  if (pid !== void 0 && cmd.pid !== pid) return;
+  console.log(`[registry] finalize: id=${commandId}, exitCode=${exitCode}, cmd="${cmd.command}", server=${getServerId()}`);
+  notifyExitListeners(commandId, exitCode);
+  finalizeTerminal(commandId, exitCode);
+  const output = getBufferedOutput(cmd);
+  registry2.delete(commandId);
+  const entry = {
+    id: cmd.commandId,
+    command: cmd.command,
+    output: "",
+    exitCode,
+    timestamp: cmd.timestamp,
+    cwd: cmd.cwd,
+    ...cmd.usePty ? { usePty: true } : {}
+  };
+  const historyPath = getTerminalHistoryPath(cmd.projectCwd, cmd.tabId);
+  await ensureParentDir(historyPath);
+  if (output.length > OUTPUT_FILE_THRESHOLD) {
+    const outputPath = getTerminalOutputPath(cmd.projectCwd, cmd.commandId);
+    await fs.writeFile(outputPath, output, "utf-8");
+    entry.outputFile = outputPath;
+  } else {
+    entry.output = output;
+  }
+  let existingLines = [];
+  try {
+    const content = await fs.readFile(historyPath, "utf-8");
+    existingLines = content.trim().split("\n").filter(Boolean);
+  } catch {
+  }
+  let replaced = false;
+  for (let i = 0; i < existingLines.length; i++) {
+    try {
+      if (JSON.parse(existingLines[i]).id === commandId) {
+        existingLines[i] = JSON.stringify(entry);
+        replaced = true;
+        break;
+      }
+    } catch {
+    }
+  }
+  if (!replaced) {
+    existingLines.push(JSON.stringify(entry));
+  }
+  await fs.writeFile(historyPath, existingLines.join("\n") + "\n", "utf-8");
+}
+
+// src/lib/bubbles/browser/BrowserBridge.ts
+import { WebSocket } from "ws";
+var registry = /* @__PURE__ */ new Map();
+var fullIdToShort = /* @__PURE__ */ new Map();
+function registerBrowser(fullId, ws) {
+  const shortId = toShortId(fullId);
+  registry.set(shortId, { fullId, ws, lastSeen: Date.now() });
+  fullIdToShort.set(fullId, shortId);
+  return shortId;
+}
+function unregisterBrowser(fullId) {
+  const shortId = fullIdToShort.get(fullId);
+  if (shortId) {
+    registry.delete(shortId);
+    fullIdToShort.delete(fullId);
+  }
+}
+function getBrowserByShortId(shortId) {
+  return registry.get(shortId);
+}
+function listBrowsers() {
+  const result = [];
+  for (const [shortId, entry] of registry) {
+    result.push({
+      shortId,
+      fullId: entry.fullId,
+      connected: entry.ws !== null && entry.ws.readyState === WebSocket.OPEN
+    });
+  }
+  return result;
+}
+var pendingRequests = /* @__PURE__ */ new Map();
+function createPendingRequest(reqId, timeout) {
+  return new Promise((resolve2, reject) => {
+    const timer = setTimeout(() => {
+      pendingRequests.delete(reqId);
+      reject(new Error(`Timeout after ${timeout}ms`));
+    }, timeout);
+    pendingRequests.set(reqId, { resolve: resolve2, reject, timer });
+  });
+}
+function resolvePendingRequest(reqId, ok, data, error) {
+  const pending = pendingRequests.get(reqId);
+  if (!pending) return;
+  clearTimeout(pending.timer);
+  pendingRequests.delete(reqId);
+  if (ok) {
+    pending.resolve(data);
+  } else {
+    pending.reject(new Error(error || "Browser command failed"));
+  }
+}
+function sendCommandToBrowser(shortId, reqId, action, params) {
+  const entry = registry.get(shortId);
+  if (!entry || !entry.ws || entry.ws.readyState !== WebSocket.OPEN) {
+    return false;
+  }
+  entry.ws.send(JSON.stringify({
+    type: "browser:cmd",
+    reqId,
+    action,
+    params
+  }));
+  return true;
+}
+
+// src/lib/wsServer.ts
+import { randomUUID } from "crypto";
+
+// src/lib/platform.ts
+var isMac = process.platform === "darwin";
+var isWindows = process.platform === "win32";
+var isLinux = process.platform === "linux";
+function getDefaultShell() {
+  if (isWindows) return process.env.COMSPEC || "powershell.exe";
+  return process.env.SHELL || "/bin/sh";
+}
+function getDefaultPath() {
+  if (isWindows) return process.env.PATH || "";
+  return process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
+}
+
+// src/lib/wsServer.ts
+var HEARTBEAT_INTERVAL = 3e4;
+var globalStateClients = /* @__PURE__ */ new Set();
+function broadcastToGlobalState(msg) {
+  const data = JSON.stringify(msg);
+  for (const ws of globalStateClients) {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(data);
+    }
+  }
+}
+var wss = new WebSocketServer({ noServer: true });
+wss.on("connection", (ws, req) => {
+  const { pathname, query } = parse(req.url || "", true);
+  if (pathname === "/ws/watch") {
+    handleFileWatch(ws, query.cwd);
+  } else if (pathname === "/ws/global-state") {
+    handleGlobalState(ws);
+  } else if (pathname === "/ws/terminal") {
+    handleTerminal(ws, query.projectCwd);
+  } else if (pathname === "/ws/browser") {
+    handleBrowser(ws, query.fullId);
+  } else if (pathname === "/ws/terminal-follow") {
+    handleTerminalFollow(ws, query.id);
+  } else if (pathname === "/ws/jupyter") {
+    handleJupyter(ws, query.bubbleId, query.cwd);
+  }
+});
+function handleUpgrade(req, socket, head) {
+  const { pathname } = parse(req.url || "", true);
+  if (pathname === "/ws/watch" || pathname === "/ws/global-state" || pathname === "/ws/terminal" || pathname === "/ws/browser" || pathname === "/ws/terminal-follow" || pathname === "/ws/jupyter") {
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      wss.emit("connection", ws, req);
+    });
+    return true;
+  }
+  return false;
+}
+function handleFileWatch(ws, cwd) {
+  if (!cwd) {
+    ws.close(4400, "Missing cwd parameter");
+    return;
+  }
+  const send = (events) => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "watch", data: events }));
+    }
+  };
+  const unsubscribe = fileWatcher.subscribe(cwd, send);
+  const unsubReview = reviewWatcher.subscribe(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "watch", data: [{ type: "review" }] }));
+    }
+  });
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  ws.on("close", () => {
+    unsubscribe();
+    unsubReview();
+    clearInterval(heartbeat);
+  });
+}
+function handleGlobalState(ws) {
+  globalStateClients.add(ws);
+  let closed = false;
+  const sendState = async () => {
+    if (closed || ws.readyState !== WebSocket2.OPEN) return;
+    try {
+      const state = await readJsonFile(GLOBAL_STATE_FILE, { sessions: [] });
+      for (const s of state.sessions) {
+        if (!s.status) {
+          const legacy = s;
+          s.status = legacy.isLoading ? "loading" : "normal";
+        }
+      }
+      state.sessions.sort((a, b) => b.lastActive - a.lastActive);
+      const recentSessions = state.sessions.slice(0, 15);
+      const sessionsWithLastMessage = await Promise.all(
+        recentSessions.map(async (session) => {
+          if (session.status === "loading" && session.lastUserMessage) {
+            return session;
+          }
+          const lastUserMessage = await getLastUserMessage(session.cwd, session.sessionId);
+          return { ...session, lastUserMessage };
+        })
+      );
+      if (closed || ws.readyState !== WebSocket2.OPEN) return;
+      ws.send(JSON.stringify({ type: "global-state", data: { sessions: sessionsWithLastMessage } }));
+    } catch (err) {
+      if (!closed) console.error("Global state watch error:", err);
+    }
+  };
+  let sending = false;
+  let pendingSend = false;
+  const scheduleSend = () => {
+    if (sending) {
+      pendingSend = true;
+      return;
+    }
+    sending = true;
+    sendState().finally(() => {
+      sending = false;
+      if (pendingSend) {
+        pendingSend = false;
+        scheduleSend();
+      }
+    });
+  };
+  scheduleSend();
+  const dir = dirname(GLOBAL_STATE_FILE);
+  if (!existsSync2(dir)) {
+    mkdirSync2(dir, { recursive: true });
+  }
+  let watcher = null;
+  try {
+    watcher = watch2(GLOBAL_STATE_FILE, () => {
+      scheduleSend();
+    });
+    watcher.on("error", (error) => {
+      console.error("Global state file watcher error:", error);
+    });
+  } catch {
+    try {
+      watcher = watch2(dir, (_, filename) => {
+        if (filename === "state.json") {
+          scheduleSend();
+        }
+      });
+    } catch (err) {
+      console.error("Global state dir watcher error:", err);
+    }
+  }
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  ws.on("close", () => {
+    closed = true;
+    globalStateClients.delete(ws);
+    if (watcher) watcher.close();
+    clearInterval(heartbeat);
+  });
+}
+function getDescendantPids(pid) {
+  const descendants = [];
+  function collect(parentPid) {
+    try {
+      let result;
+      if (isWindows) {
+        result = execSync(`wmic process where (ParentProcessId=${parentPid}) get ProcessId /format:list`, { encoding: "utf-8", timeout: 3e3 }).trim();
+        const childPids = result.split("\n").map((l) => l.replace(/\r/, "").match(/ProcessId=(\d+)/)?.[1]).filter(Boolean).map(Number);
+        for (const childPid of childPids) {
+          collect(childPid);
+          descendants.push(childPid);
+        }
+      } else {
+        result = execSync(`pgrep -P ${parentPid}`, { encoding: "utf-8", timeout: 3e3 }).trim();
+        const childPids = result.split("\n").filter(Boolean).map(Number);
+        for (const childPid of childPids) {
+          collect(childPid);
+          descendants.push(childPid);
+        }
+      }
+    } catch {
+    }
+  }
+  collect(pid);
+  return descendants;
+}
+function handleTerminal(ws, projectCwd) {
+  if (!projectCwd) {
+    ws.close(4400, "Missing projectCwd parameter");
+    return;
+  }
+  let closed = false;
+  const cleanupMap = /* @__PURE__ */ new Map();
+  const send = (msg) => {
+    if (!closed && ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  };
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  function attachPipeListeners(commandId, child) {
+    const oldCleanup = cleanupMap.get(commandId);
+    if (oldCleanup) oldCleanup();
+    const onStdout = (data) => {
+      send({ type: "stdout", commandId, data: data.toString() });
+    };
+    const onStderr = (data) => {
+      send({ type: "stderr", commandId, data: data.toString() });
+    };
+    const pid = child.pid;
+    const onClose = async (code) => {
+      const exitCode = code ?? 0;
+      send({ type: "exit", commandId, code: exitCode });
+      try {
+        await finalizeCommand(commandId, exitCode, pid);
+      } catch (e) {
+        console.error("[ws/terminal] finalize error:", e);
+      }
+      cleanupMap.delete(commandId);
+    };
+    const onError = async (error) => {
+      send({ type: "error", commandId, error: error.message });
+      try {
+        await finalizeCommand(commandId, 1, pid);
+      } catch (e) {
+        console.error("[ws/terminal] finalize error:", e);
+      }
+      cleanupMap.delete(commandId);
+    };
+    child.stdout?.on("data", onStdout);
+    child.stderr?.on("data", onStderr);
+    child.on("close", onClose);
+    child.on("error", onError);
+    const cleanup = () => {
+      child.stdout?.off("data", onStdout);
+      child.stderr?.off("data", onStderr);
+      child.off("close", onClose);
+      child.off("error", onError);
+    };
+    cleanupMap.set(commandId, cleanup);
+  }
+  function attachPtyListeners(commandId, pty) {
+    const oldCleanup = cleanupMap.get(commandId);
+    if (oldCleanup) oldCleanup();
+    const dataDisposable = pty.onData((data) => {
+      send({ type: "stdout", commandId, data });
+    });
+    const ptyPid = pty.pid;
+    const exitDisposable = pty.onExit(async ({ exitCode }) => {
+      send({ type: "exit", commandId, code: exitCode });
+      try {
+        await finalizeCommand(commandId, exitCode, ptyPid);
+      } catch (e) {
+        console.error("[ws/terminal] finalize error:", e);
+      }
+      cleanupMap.delete(commandId);
+    });
+    const cleanup = () => {
+      dataDisposable.dispose();
+      exitDisposable.dispose();
+    };
+    cleanupMap.set(commandId, cleanup);
+  }
+  ws.on("message", (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    const type = msg.type;
+    if (type === "exec") {
+      const { commandId, command, cwd, tabId, env, usePty, cols, rows } = msg;
+      if (!commandId || !command || !cwd || !tabId) {
+        send({ type: "error", commandId: commandId || "", error: "Missing required parameters" });
+        return;
+      }
+      const childEnv = {
+        HOME: process.env.HOME,
+        USER: process.env.USER,
+        SHELL: process.env.SHELL,
+        TERM: "xterm-256color",
+        FORCE_COLOR: "1",
+        CLICOLOR: "1",
+        CLICOLOR_FORCE: "1",
+        PYTHONUNBUFFERED: "1",
+        npm_config_color: "always",
+        ...env
+      };
+      try {
+        const userShell = getDefaultShell();
+        if (usePty) {
+          const ptyEnv = {
+            PATH: getDefaultPath()
+          };
+          for (const [k, v] of Object.entries(childEnv)) {
+            if (v !== void 0) ptyEnv[k] = v;
+          }
+          const ptyProcess = nodePty.spawn(userShell, ["--login", "-c", command], {
+            name: "xterm-256color",
+            cols: cols || 120,
+            rows: rows || 30,
+            cwd,
+            env: ptyEnv
+          });
+          const dummyChild = spawn("true", [], { stdio: "ignore" });
+          registerCommand({
+            commandId,
+            command,
+            cwd,
+            projectCwd,
+            tabId,
+            pid: ptyProcess.pid,
+            process: dummyChild,
+            ptyProcess,
+            usePty: true,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          send({ type: "pid", commandId, pid: ptyProcess.pid });
+          attachPtyListeners(commandId, ptyProcess);
+        } else {
+          const child = spawn(userShell, ["--login", "-c", command], {
+            cwd,
+            env: childEnv,
+            stdio: ["pipe", "pipe", "pipe"],
+            detached: true
+          });
+          if (child.pid) {
+            registerCommand({
+              commandId,
+              command,
+              cwd,
+              projectCwd,
+              tabId,
+              pid: child.pid,
+              process: child,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            send({ type: "pid", commandId, pid: child.pid });
+            attachPipeListeners(commandId, child);
+          } else {
+            send({ type: "error", commandId, error: "Failed to spawn process" });
+          }
+        }
+      } catch (e) {
+        send({ type: "error", commandId, error: e.message });
+      }
+    } else if (type === "stdin") {
+      const { commandId, data } = msg;
+      const cmd = getRunningCommand(commandId);
+      if (!cmd) return;
+      if (cmd.usePty && cmd.ptyProcess) {
+        try {
+          cmd.ptyProcess.write(data);
+        } catch {
+        }
+      } else {
+        if (data === "" && cmd.pid) {
+          try {
+            process.kill(-cmd.pid, "SIGINT");
+          } catch {
+            try {
+              process.kill(cmd.pid, "SIGINT");
+            } catch {
+            }
+          }
+        } else if (data === "" && cmd.pid) {
+          try {
+            process.kill(cmd.pid, "SIGTSTP");
+          } catch {
+          }
+        } else if (data === "") {
+          try {
+            cmd.process.stdin?.end();
+          } catch {
+          }
+        } else if (cmd.process.stdin?.writable) {
+          cmd.process.stdin.write(data);
+        }
+      }
+    } else if (type === "attach") {
+      const { commandId } = msg;
+      const cmd = getRunningCommand(commandId);
+      if (!cmd) {
+        send({ type: "error", commandId, error: "Command not found or already finished" });
+        return;
+      }
+      send({ type: "pid", commandId, pid: cmd.pid });
+      const buffered = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+      if (buffered) {
+        send({ type: "stdout", commandId, data: buffered });
+      }
+      if (cmd.usePty && cmd.ptyProcess) {
+        attachPtyListeners(commandId, cmd.ptyProcess);
+      } else {
+        attachPipeListeners(commandId, cmd.process);
+      }
+    } else if (type === "interrupt") {
+      const { pid } = msg;
+      if (!pid) return;
+      const descendants = getDescendantPids(pid);
+      const allPids = [...descendants, pid];
+      for (const p of allPids) {
+        try {
+          process.kill(p, "SIGTERM");
+        } catch {
+        }
+      }
+      setTimeout(() => {
+        for (const p of allPids) {
+          try {
+            process.kill(p, 0);
+            process.kill(p, "SIGKILL");
+          } catch {
+          }
+        }
+      }, 1e3);
+    } else if (type === "resize") {
+      const { commandId, cols, rows } = msg;
+      const cmd = getRunningCommand(commandId);
+      if (cmd?.usePty && cmd.ptyProcess) {
+        try {
+          cmd.ptyProcess.resize(cols, rows);
+        } catch {
+        }
+      }
+    } else if (type === "running") {
+      const commands = getRunningCommands(projectCwd);
+      if (commands.length === 0) {
+        const size = getRegistrySize();
+        const cwds = getAllProjectCwds();
+        console.warn(`[ws/terminal] running query: 0 commands for projectCwd="${projectCwd}", registry total=${size}, cwds=${JSON.stringify(cwds)}`);
+      }
+      send({ type: "running", commands });
+    }
+  });
+  ws.on("close", () => {
+    closed = true;
+    clearInterval(heartbeat);
+    for (const cleanup of cleanupMap.values()) {
+      cleanup();
+    }
+    cleanupMap.clear();
+  });
+}
+async function readFinishedOutput(projectCwd, tabId, commandId) {
+  try {
+    const historyPath = getTerminalHistoryPath(projectCwd, tabId);
+    const content = await readFile(historyPath, "utf-8");
+    for (const line of content.trim().split("\n").reverse()) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.id === commandId) {
+          let output = entry.output || "";
+          if (entry.outputFile) {
+            try {
+              output = await readFile(entry.outputFile, "utf-8");
+            } catch {
+            }
+          }
+          return { output, exitCode: entry.exitCode ?? 0 };
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function handleTerminalApi(req, res) {
+  const { pathname } = parse(req.url || "", true);
+  const match = pathname?.match(/^\/api\/terminal\/([a-z]+)$/);
+  if (!match || req.method !== "POST") return false;
+  const action = match[1];
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  let body;
+  try {
+    body = JSON.parse(Buffer.concat(chunks).toString());
+  } catch {
+    body = {};
+  }
+  const sendJson = (status, data) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  };
+  if (action === "list") {
+    sendJson(200, { ok: true, data: listTerminals(getRunningCommand) });
+    return true;
+  }
+  if (action === "register") {
+    const { tabId, commandId, command, projectCwd } = body;
+    if (!tabId || !commandId || !command) {
+      sendJson(400, { ok: false, error: "Missing tabId/commandId/command" });
+      return true;
+    }
+    const shortId = registerTerminal(tabId, commandId, command, projectCwd);
+    sendJson(200, { ok: true, data: { shortId } });
+    return true;
+  }
+  if (action === "unregister") {
+    const { commandId } = body;
+    if (!commandId) {
+      sendJson(400, { ok: false, error: "Missing commandId" });
+      return true;
+    }
+    unregisterTerminal(commandId);
+    sendJson(200, { ok: true });
+    return true;
+  }
+  const { id } = body;
+  if (!id) {
+    sendJson(400, { ok: false, error: "Missing terminal id" });
+    return true;
+  }
+  const entry = getTerminalByShortId(id);
+  if (!entry) {
+    sendJson(404, { ok: false, error: `Terminal "${id}" not found` });
+    return true;
+  }
+  const cmd = getRunningCommand(entry.commandId);
+  if (action === "output") {
+    if (cmd) {
+      const output = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+      sendJson(200, { ok: true, data: { output, command: entry.command, pid: cmd.pid, running: true } });
+    } else {
+      if (!entry.projectCwd) {
+        sendJson(404, { ok: false, error: "Command projectCwd unknown" });
+        return true;
+      }
+      const historyOutput = await readFinishedOutput(entry.projectCwd, entry.tabId, entry.commandId);
+      if (historyOutput !== void 0) {
+        sendJson(200, { ok: true, data: { output: historyOutput.output, command: entry.command, exitCode: historyOutput.exitCode, running: false } });
+      } else {
+        sendJson(404, { ok: false, error: "Command output not available" });
+      }
+    }
+    return true;
+  }
+  if (action === "stdin") {
+    if (!cmd) {
+      sendJson(404, { ok: false, error: "Command no longer running" });
+      return true;
+    }
+    const { data } = body;
+    if (data === void 0) {
+      sendJson(400, { ok: false, error: "Missing data" });
+      return true;
+    }
+    if (cmd.usePty && cmd.ptyProcess) {
+      try {
+        cmd.ptyProcess.write(data);
+      } catch {
+      }
+    } else if (cmd.process.stdin?.writable) {
+      cmd.process.stdin.write(data);
+    } else {
+      sendJson(500, { ok: false, error: "stdin not writable" });
+      return true;
+    }
+    sendJson(200, { ok: true });
+    return true;
+  }
+  sendJson(400, { ok: false, error: `Unknown action: ${action}` });
+  return true;
+}
+function handleTerminalFollow(ws, shortId) {
+  if (!shortId) {
+    ws.close(4400, "Missing id parameter");
+    return;
+  }
+  const entry = getTerminalByShortId(shortId);
+  if (!entry) {
+    ws.close(4404, "Terminal not found");
+    return;
+  }
+  const cmd = getRunningCommand(entry.commandId);
+  if (cmd) {
+    const buffered = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+    if (buffered) {
+      ws.send(JSON.stringify({ type: "output", data: buffered }));
+    }
+  }
+  const unsubOutput = addOutputListener(entry.commandId, (data) => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "output", data }));
+    }
+  });
+  const unsubExit = addExitListener(entry.commandId, (code) => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "exit", code }));
+      ws.close();
+    }
+  });
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  ws.on("close", () => {
+    unsubOutput();
+    unsubExit();
+    clearInterval(heartbeat);
+  });
+}
+async function handleBrowserApi(req, res) {
+  const { pathname } = parse(req.url || "", true);
+  const match = pathname?.match(/^\/api\/browser\/([a-z][a-z_]*)$/);
+  if (!match || req.method !== "POST") return false;
+  const action = match[1];
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  let body;
+  try {
+    body = JSON.parse(Buffer.concat(chunks).toString());
+  } catch {
+    body = {};
+  }
+  const { id, params: cmdParams = {}, timeout = 1e4 } = body;
+  const sendJson = (status, data) => {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data));
+  };
+  if (action === "list") {
+    sendJson(200, { ok: true, data: listBrowsers() });
+    return true;
+  }
+  if (action === "unregister") {
+    if (!id) {
+      sendJson(400, { ok: false, error: "Missing browser id" });
+      return true;
+    }
+    const browser2 = getBrowserByShortId(id);
+    if (browser2) {
+      if (browser2.ws && browser2.ws.readyState === WebSocket2.OPEN) {
+        browser2.ws.close();
+      }
+      unregisterBrowser(browser2.fullId);
+    }
+    sendJson(200, { ok: true });
+    return true;
+  }
+  if (!id) {
+    sendJson(400, { ok: false, error: "Missing browser id" });
+    return true;
+  }
+  const browser = getBrowserByShortId(id);
+  if (!browser) {
+    sendJson(404, { ok: false, error: `Browser "${id}" not found` });
+    return true;
+  }
+  if (!browser.ws || browser.ws.readyState !== WebSocket2.OPEN) {
+    sendJson(503, { ok: false, error: `Browser "${id}" is disconnected` });
+    return true;
+  }
+  const reqId = `r-${randomUUID().slice(0, 8)}`;
+  const sent = sendCommandToBrowser(id, reqId, action, cmdParams);
+  if (!sent) {
+    sendJson(503, { ok: false, error: "Failed to send command" });
+    return true;
+  }
+  try {
+    const data = await createPendingRequest(reqId, timeout);
+    sendJson(200, { ok: true, data });
+  } catch (err) {
+    sendJson(504, { ok: false, error: err.message });
+  }
+  return true;
+}
+function handleBrowser(ws, fullId) {
+  if (!fullId) {
+    ws.close(4400, "Missing fullId parameter");
+    return;
+  }
+  const shortId = registerBrowser(fullId, ws);
+  ws.send(JSON.stringify({ type: "registered", shortId }));
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  ws.on("message", (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    if (msg.type === "browser:cmd-result") {
+      const { reqId, ok, data, error } = msg;
+      resolvePendingRequest(reqId, ok, data, error);
+    }
+  });
+  ws.on("close", () => {
+    clearInterval(heartbeat);
+    unregisterBrowser(fullId);
+  });
+}
+async function handleJupyter(ws, bubbleId, cwd) {
+  if (!bubbleId || !cwd) {
+    ws.close(4400, "Missing bubbleId or cwd parameter");
+    return;
+  }
+  let closed = false;
+  const send = (msg) => {
+    if (!closed && ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify(msg));
+    }
+  };
+  const heartbeat = setInterval(() => {
+    if (ws.readyState === WebSocket2.OPEN) {
+      ws.send(JSON.stringify({ type: "ping" }));
+    }
+  }, HEARTBEAT_INTERVAL);
+  const { kernelManager } = await import("./JupyterKernelManager-475VNVA5.mjs");
+  try {
+    const instance = await kernelManager.getOrCreate(bubbleId, cwd);
+    if (instance.errorMessage) {
+      send({ type: "kernel_error", message: instance.errorMessage });
+    } else {
+      send({ type: "ready" });
+    }
+  } catch (err) {
+    send({ type: "kernel_error", message: err.message });
+  }
+  const unsubscribe = kernelManager.addOutputListener(bubbleId, (msg) => {
+    if (msg.msg_type === "kernel_error") {
+      send({ type: "kernel_error", message: msg.content.message });
+    } else if (msg.msg_type === "kernel_died") {
+      send({ type: "kernel_died", exit_code: msg.content.exit_code });
+    } else if (msg.msg_type === "status") {
+      send({ type: "status", execution_state: msg.content.execution_state });
+    } else {
+      send({ type: "output", msg_id: msg.msg_id, msg_type: msg.msg_type, content: msg.content });
+    }
+  });
+  ws.on("message", async (raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch {
+      return;
+    }
+    const type = msg.type;
+    if (type === "execute") {
+      const { msg_id, code } = msg;
+      try {
+        await kernelManager.execute(bubbleId, code, msg_id, cwd);
+      } catch (err) {
+        send({ type: "kernel_error", message: err.message });
+      }
+    } else if (type === "interrupt") {
+      await kernelManager.interrupt(bubbleId);
+    }
+  });
+  ws.on("close", () => {
+    closed = true;
+    clearInterval(heartbeat);
+    unsubscribe();
+  });
+}
+export {
+  broadcastToGlobalState,
+  handleBrowserApi,
+  handleTerminalApi,
+  handleUpgrade
+};