@surething/cockpit 1.0.208 → 1.0.209

package/dist/wsServer.mjs

@@ -1,47 +1,94 @@
 import {
+  AppError,
+  Effect_exports,
+  FSError,
+  NotFoundError,
+  PubSub_exports,
+  Queue_exports,
+  Schedule_exports,
+  Stream_exports,
+  ValidationError,
+  WSError,
   getLastUserMessage
-} from "./chunk-HIRLDMCH.mjs";
+} from "./chunk-OWUW2O3D.mjs";
 import {
   addExitListener,
   addOutputListener,
-  createPendingRequest,
   finalizeCommand,
   findSafeStart,
   getAllProjectCwds,
-  getBrowserByShortId,
   getRegistrySize,
   getRunningCommand,
   getRunningCommands,
   getTerminalByShortId,
-  listBrowsers,
-  listTerminals,
   registerBrowser,
   registerCommand,
-  registerTerminal,
   resolvePendingRequest,
-  sendCommandToBrowser,
-  unregisterBrowser,
-  unregisterTerminal
-} from "./chunk-VCZEGP64.mjs";
+  unregisterBrowser
+} from "./chunk-FBR4KJI5.mjs";
 import {
   GLOBAL_STATE_FILE,
   REVIEW_DIR,
   REVIEW_SIGNAL_FILE,
-  getTerminalHistoryPath,
   readJsonFile
-} from "./chunk-RSHKDWJM.mjs";
+} from "./chunk-TXBVUZVH.mjs";
 
 // src/lib/wsServer.ts
 import { WebSocketServer, WebSocket } from "ws";
 import { parse } from "url";
-import { watch as watch2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+
+// src/lib/effect/globalStateHandler.ts
+import { watch, existsSync, mkdirSync } 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";
+// packages/shared/effect-runtime/src/server/wsAdapter.ts
+var fromWebSocket = (ws, proto) => Effect_exports.gen(function* () {
+  const pubsub = yield* PubSub_exports.unbounded();
+  yield* Effect_exports.acquireRelease(
+    Effect_exports.sync(() => {
+      const onMessage = (data) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(String(data));
+        } catch {
+          parsed = data;
+        }
+        Effect_exports.runFork(PubSub_exports.publish(pubsub, parsed));
+      };
+      const onClose = () => {
+        Effect_exports.runFork(PubSub_exports.shutdown(pubsub));
+      };
+      const onError = () => {
+        Effect_exports.runFork(PubSub_exports.shutdown(pubsub));
+      };
+      ws.on("message", onMessage);
+      ws.on("close", onClose);
+      ws.on("error", onError);
+      return { onMessage, onClose, onError };
+    }),
+    (handlers) => Effect_exports.sync(() => {
+      ws.off("message", handlers.onMessage);
+      ws.off("close", handlers.onClose);
+      ws.off("error", handlers.onError);
+    })
+  );
+  const send = (msg) => Effect_exports.try({
+    try: () => {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(JSON.stringify(msg));
+      }
+    },
+    catch: (cause) => new WSError({ proto, kind: "send", cause })
+  });
+  const messages = Stream_exports.fromPubSub(pubsub);
+  const close = Effect_exports.sync(() => {
+    try {
+      ws.close();
+    } catch {
+    }
+  });
+  return { send, messages, close };
+});
 
 // packages/shared/utils/src/platform.ts
 var isMac = process.platform === "darwin";
@@ -56,7 +103,96 @@ function getDefaultPath() {
   return process.env.PATH || "/usr/local/bin:/usr/bin:/bin";
 }
 
+// src/lib/effect/globalStateHandler.ts
+var HEARTBEAT_INTERVAL = Schedule_exports.spaced("30 seconds");
+var sendGlobalState = (conn) => Effect_exports.gen(function* () {
+  const state = yield* Effect_exports.tryPromise({
+    try: () => readJsonFile(GLOBAL_STATE_FILE, { sessions: [] }),
+    catch: (cause) => new FSError({ path: GLOBAL_STATE_FILE, op: "read", cause })
+  });
+  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 recent = state.sessions.slice(0, 15);
+  const sessions = yield* Effect_exports.forEach(
+    recent,
+    (session) => session.status === "loading" && session.lastUserMessage ? Effect_exports.succeed(session) : Effect_exports.tryPromise({
+      try: () => getLastUserMessage(session.cwd, session.sessionId),
+      catch: () => void 0
+    }).pipe(
+      Effect_exports.map((lastUserMessage) => ({ ...session, lastUserMessage })),
+      Effect_exports.orElseSucceed(() => session)
+    ),
+    { concurrency: "unbounded" }
+  );
+  yield* conn.send({ type: "global-state", data: { sessions } });
+});
+var watchStateFile = (trigger) => Effect_exports.acquireRelease(
+  Effect_exports.sync(() => {
+    const dir = dirname(GLOBAL_STATE_FILE);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    const offer = () => Effect_exports.runFork(Queue_exports.offer(trigger, void 0));
+    let watcher = null;
+    try {
+      watcher = watch(GLOBAL_STATE_FILE, () => offer());
+    } catch {
+      try {
+        watcher = watch(dir, (_, filename) => {
+          if (filename === "state.json") offer();
+        });
+      } catch {
+      }
+    }
+    watcher?.on("error", () => {
+    });
+    return watcher;
+  }),
+  (watcher) => Effect_exports.sync(() => {
+    try {
+      watcher?.close();
+    } catch {
+    }
+  })
+).pipe(Effect_exports.asVoid);
+var handleGlobalState = (conn) => Effect_exports.gen(function* () {
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT_INTERVAL)
+  );
+  const trigger = yield* Queue_exports.unbounded();
+  yield* watchStateFile(trigger);
+  yield* Queue_exports.offer(trigger, void 0);
+  yield* Stream_exports.fromQueue(trigger).pipe(
+    Stream_exports.debounce("50 millis"),
+    Stream_exports.mapEffect(
+      () => sendGlobalState(conn).pipe(
+        Effect_exports.catchAll(
+          (e) => Effect_exports.sync(() => console.error("[ws/global-state]", e))
+        )
+      )
+    ),
+    Stream_exports.runDrain
+  );
+});
+var runGlobalStateHandler = (ws) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "global-state");
+      yield* handleGlobalState(conn);
+    })
+  );
+  const fiber = Effect_exports.runFork(program);
+  ws.on("close", () => {
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
+  });
+};
+
 // src/lib/fileWatcher.ts
+import { watch as watch2, readFileSync, statSync, existsSync as existsSync2, mkdirSync as mkdirSync2, 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.
@@ -146,7 +282,7 @@ var FileWatcherManager = class {
     };
     const startCwdWatcher = () => {
       try {
-        const cwdWatcher = watch(cwd, { recursive: true }, (_eventType, filename) => {
+        const cwdWatcher = watch2(cwd, { recursive: true }, (_eventType, filename) => {
           if (!filename) return;
           if (filename.startsWith(".next/") || filename.startsWith("node_modules/")) return;
           if (filename.startsWith(".git/")) {
@@ -181,7 +317,7 @@ var FileWatcherManager = class {
     const gitDir = resolveGitDir(cwd);
     const watchGitFile = (filePath) => {
       try {
-        const w = watch(filePath, () => {
+        const w = watch2(filePath, () => {
           pushEvent({ type: "git" });
           try {
             w.close();
@@ -196,7 +332,7 @@ var FileWatcherManager = class {
         w.on("error", () => {
           const idx = entry.watchers.indexOf(w);
           if (idx !== -1) entry.watchers.splice(idx, 1);
-          if (entry.listeners.size > 0 && existsSync(filePath)) {
+          if (entry.listeners.size > 0 && existsSync2(filePath)) {
             setTimeout(() => watchGitFile(filePath), 500);
           }
         });
@@ -211,7 +347,7 @@ var FileWatcherManager = class {
     for (const gitDirName of GIT_WATCH_DIRS) {
       const dirName = gitDirName.replace(".git/", "");
       try {
-        const w = watch(join(gitDir, dirName), { recursive: true }, () => {
+        const w = watch2(join(gitDir, dirName), { recursive: true }, () => {
           pushEvent({ type: "git" });
         });
         w.on("error", () => {
@@ -259,9 +395,9 @@ var ReviewWatcher = class {
   }
   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 (!existsSync2(REVIEW_DIR)) mkdirSync2(REVIEW_DIR, { recursive: true });
+      if (!existsSync2(REVIEW_SIGNAL_FILE)) writeFileSync(REVIEW_SIGNAL_FILE, "0");
+      this.watcher = watch2(REVIEW_SIGNAL_FILE, () => {
         if (this.debounceTimer) clearTimeout(this.debounceTimer);
         this.debounceTimer = setTimeout(() => this.notify(), 300);
       });
@@ -301,178 +437,404 @@ var g_watch = globalThis;
 var fileWatcher = g_watch.__cockpitFileWatcher ?? (g_watch.__cockpitFileWatcher = new FileWatcherManager());
 var reviewWatcher = g_watch.__cockpitReviewWatcher ?? (g_watch.__cockpitReviewWatcher = new ReviewWatcher());
 
-// src/lib/wsServer.ts
-import { readFile } from "fs/promises";
-import { randomUUID } from "crypto";
-var HEARTBEAT_INTERVAL = 3e4;
-var g_ws = globalThis;
-var globalStateClients = g_ws.__cockpitGlobalStateClients ?? (g_ws.__cockpitGlobalStateClients = /* @__PURE__ */ new Set());
-function broadcastToGlobalState(msg) {
-  const data = JSON.stringify(msg);
-  for (const ws of globalStateClients) {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(data);
-    }
+// src/lib/effect/fileWatchHandler.ts
+var HEARTBEAT = Schedule_exports.spaced("30 seconds");
+var fileEvents = (cwd) => Stream_exports.unwrapScoped(
+  Effect_exports.gen(function* () {
+    const queue = yield* Queue_exports.unbounded();
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(
+        () => fileWatcher.subscribe(cwd, (events) => {
+          Effect_exports.runFork(Queue_exports.offer(queue, events));
+        })
+      ),
+      (unsubscribe) => Effect_exports.sync(unsubscribe)
+    );
+    return Stream_exports.fromQueue(queue);
+  })
+);
+var reviewEvents = Stream_exports.unwrapScoped(
+  Effect_exports.gen(function* () {
+    const queue = yield* Queue_exports.unbounded();
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(
+        () => reviewWatcher.subscribe(() => {
+          Effect_exports.runFork(Queue_exports.offer(queue, void 0));
+        })
+      ),
+      (unsubscribe) => Effect_exports.sync(unsubscribe)
+    );
+    return Stream_exports.fromQueue(queue);
+  })
+);
+var handleFileWatch = (conn, cwd) => Effect_exports.gen(function* () {
+  if (!cwd) {
+    return yield* Effect_exports.fail(
+      new ValidationError({ field: "cwd", reason: "missing" })
+    );
   }
-}
-var wss = g_ws.__cockpitWss ?? (() => {
-  const server = new WebSocketServer({ noServer: true });
-  g_ws.__cockpitWss = server;
-  server.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);
-    }
+  yield* Effect_exports.logInfo("ws/watch start").pipe(
+    Effect_exports.annotateLogs("cwd", cwd)
+  );
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT)
+  );
+  yield* Effect_exports.forkScoped(
+    reviewEvents.pipe(
+      Stream_exports.mapEffect(
+        () => conn.send({ type: "watch", data: [{ type: "review" }] })
+      ),
+      Stream_exports.runDrain
+    )
+  );
+  yield* fileEvents(cwd).pipe(
+    Stream_exports.mapEffect(
+      (events) => conn.send({ type: "watch", data: events })
+    ),
+    Stream_exports.runDrain
+  );
+}).pipe(Effect_exports.withSpan("ws.handleFileWatch", { attributes: { cwd } }));
+var runFileWatchHandler = (ws, cwd) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "watch");
+      yield* handleFileWatch(conn, cwd);
+    })
+  ).pipe(
+    Effect_exports.catchTag(
+      "ValidationError",
+      (e) => Effect_exports.sync(() => ws.close(4400, e.reason))
+    ),
+    Effect_exports.catchAll(
+      (e) => Effect_exports.logError("[ws/watch]").pipe(
+        Effect_exports.annotateLogs("error", JSON.stringify(e))
+      )
+    )
+  );
+  const fiber = Effect_exports.runFork(program);
+  ws.on("close", () => {
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
   });
-  return server;
-})();
-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;
+};
+
+// src/lib/effect/terminalFollowHandler.ts
+var HEARTBEAT2 = Schedule_exports.spaced("30 seconds");
+var subscribeTerminal = (commandId) => Stream_exports.unwrapScoped(
+  Effect_exports.gen(function* () {
+    const queue = yield* Queue_exports.unbounded();
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(
+        () => addOutputListener(commandId, (data) => {
+          Effect_exports.runFork(Queue_exports.offer(queue, { _tag: "output", data }));
+        })
+      ),
+      (unsub) => Effect_exports.sync(unsub)
+    );
+    yield* Effect_exports.acquireRelease(
+      Effect_exports.sync(
+        () => addExitListener(commandId, (code) => {
+          Effect_exports.runFork(Queue_exports.offer(queue, { _tag: "exit", code }));
+        })
+      ),
+      (unsub) => Effect_exports.sync(unsub)
+    );
+    return Stream_exports.fromQueue(queue);
+  })
+);
+var handleTerminalFollow = (conn, shortId) => Effect_exports.gen(function* () {
+  if (!shortId) {
+    return yield* Effect_exports.fail(
+      new ValidationError({ field: "id", reason: "missing" })
+    );
   }
-  return false;
-}
-function handleFileWatch(ws, cwd) {
-  if (!cwd) {
-    ws.close(4400, "Missing cwd parameter");
-    return;
+  const entry = getTerminalByShortId(shortId);
+  if (!entry) {
+    return yield* Effect_exports.fail(
+      new NotFoundError({ resource: "terminal", id: shortId })
+    );
   }
-  const send = (events) => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "watch", data: events }));
-    }
-  };
-  const unsubscribe = fileWatcher.subscribe(cwd, send);
-  const unsubReview = reviewWatcher.subscribe(() => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "watch", data: [{ type: "review" }] }));
+  yield* Effect_exports.logInfo("ws/terminal-follow start").pipe(
+    Effect_exports.annotateLogs("shortId", shortId),
+    Effect_exports.annotateLogs("commandId", entry.commandId)
+  );
+  const cmd = getRunningCommand(entry.commandId);
+  if (cmd) {
+    const buffered = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+    if (buffered) {
+      yield* conn.send({ type: "output", data: buffered });
     }
+  }
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT2)
+  );
+  yield* subscribeTerminal(entry.commandId).pipe(
+    Stream_exports.tap(
+      (evt) => evt._tag === "output" ? conn.send({ type: "output", data: evt.data }) : conn.send({ type: "exit", code: evt.code }).pipe(
+        Effect_exports.zipRight(conn.close)
+      )
+    ),
+    Stream_exports.takeUntil((evt) => evt._tag === "exit"),
+    Stream_exports.runDrain
+  );
+}).pipe(
+  Effect_exports.withSpan("ws.handleTerminalFollow", {
+    attributes: { shortId }
+  })
+);
+var runTerminalFollowHandler = (ws, shortId) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "terminal-follow");
+      yield* handleTerminalFollow(conn, shortId);
+    })
+  ).pipe(
+    Effect_exports.catchTag(
+      "ValidationError",
+      (e) => Effect_exports.sync(() => ws.close(4400, e.reason))
+    ),
+    Effect_exports.catchTag(
+      "NotFoundError",
+      () => Effect_exports.sync(() => ws.close(4404, "Terminal not found"))
+    ),
+    Effect_exports.catchAll(
+      (e) => Effect_exports.logError("[ws/terminal-follow]").pipe(
+        Effect_exports.annotateLogs("error", JSON.stringify(e))
+      )
+    )
+  );
+  const fiber = Effect_exports.runFork(program);
+  ws.on("close", () => {
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
   });
-  const heartbeat = setInterval(() => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "ping" }));
-    }
-  }, HEARTBEAT_INTERVAL);
+};
+
+// src/lib/effect/browserHandler.ts
+var HEARTBEAT3 = Schedule_exports.spaced("30 seconds");
+var handleBrowser = (conn, ws, fullId) => Effect_exports.gen(function* () {
+  if (!fullId) {
+    return yield* Effect_exports.fail(
+      new ValidationError({ field: "fullId", reason: "missing" })
+    );
+  }
+  const shortId = yield* Effect_exports.acquireRelease(
+    Effect_exports.sync(() => registerBrowser(fullId, ws)),
+    () => Effect_exports.sync(() => unregisterBrowser(fullId))
+  );
+  yield* Effect_exports.logInfo("ws/browser registered").pipe(
+    Effect_exports.annotateLogs("fullId", fullId),
+    Effect_exports.annotateLogs("shortId", shortId)
+  );
+  yield* conn.send({ type: "registered", shortId });
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT3)
+  );
+  yield* conn.messages.pipe(
+    Stream_exports.tap(
+      (raw) => Effect_exports.sync(() => {
+        const msg = raw;
+        if (msg?.type === "browser:cmd-result" && typeof msg.reqId === "string") {
+          resolvePendingRequest(msg.reqId, !!msg.ok, msg.data, msg.error);
+        }
+      })
+    ),
+    Stream_exports.runDrain
+  );
+}).pipe(
+  Effect_exports.withSpan("ws.handleBrowser", { attributes: { fullId } })
+);
+var runBrowserHandler = (ws, fullId) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "browser");
+      yield* handleBrowser(conn, ws, fullId);
+    })
+  ).pipe(
+    Effect_exports.catchTag(
+      "ValidationError",
+      (e) => Effect_exports.sync(() => ws.close(4400, e.reason))
+    ),
+    Effect_exports.catchAll(
+      (e) => Effect_exports.logError("[ws/browser]").pipe(
+        Effect_exports.annotateLogs("error", JSON.stringify(e))
+      )
+    )
+  );
+  const fiber = Effect_exports.runFork(program);
   ws.on("close", () => {
-    unsubscribe();
-    unsubReview();
-    clearInterval(heartbeat);
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
   });
-}
-function handleGlobalState(ws) {
-  globalStateClients.add(ws);
-  let closed = false;
-  const sendState = async () => {
-    if (closed || ws.readyState !== WebSocket.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";
+};
+
+// src/lib/effect/jupyterHandler.ts
+var HEARTBEAT4 = Schedule_exports.spaced("30 seconds");
+var handleJupyter = (conn, bubbleId, cwd) => Effect_exports.gen(function* () {
+  if (!bubbleId || !cwd) {
+    return yield* Effect_exports.fail(
+      new ValidationError({
+        field: !bubbleId ? "bubbleId" : "cwd",
+        reason: "missing"
+      })
+    );
+  }
+  yield* Effect_exports.logInfo("ws/jupyter start").pipe(
+    Effect_exports.annotateLogs("bubbleId", bubbleId),
+    Effect_exports.annotateLogs("cwd", cwd)
+  );
+  const { kernelManager } = yield* Effect_exports.tryPromise({
+    try: () => import("./server-E7G55DY7.mjs"),
+    catch: (cause) => new AppError({
+      message: "failed to import kernel manager",
+      cause
+    })
+  });
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT4)
+  );
+  yield* Effect_exports.tryPromise({
+    try: () => kernelManager.getOrCreate(bubbleId, cwd),
+    catch: (cause) => new AppError({ message: "kernel getOrCreate failed", cause })
+  }).pipe(
+    Effect_exports.flatMap(
+      (instance) => instance.errorMessage ? conn.send({
+        type: "kernel_error",
+        message: instance.errorMessage
+      }) : conn.send({ type: "ready" })
+    ),
+    Effect_exports.catchAll(
+      (e) => conn.send({
+        type: "kernel_error",
+        message: e instanceof AppError ? e.message : String(e)
+      })
+    )
+  );
+  const kernelStream = Stream_exports.unwrapScoped(
+    Effect_exports.gen(function* () {
+      const queue = yield* Queue_exports.unbounded();
+      yield* Effect_exports.acquireRelease(
+        Effect_exports.sync(
+          () => kernelManager.addOutputListener(bubbleId, (msg) => {
+            Effect_exports.runFork(Queue_exports.offer(queue, msg));
+          })
+        ),
+        (unsub) => Effect_exports.sync(unsub)
+      );
+      return Stream_exports.fromQueue(queue);
+    })
+  );
+  yield* Effect_exports.forkScoped(
+    kernelStream.pipe(
+      Stream_exports.mapEffect((msg) => {
+        if (msg.msg_type === "kernel_error") {
+          return conn.send({
+            type: "kernel_error",
+            message: msg.content.message
+          });
         }
+        if (msg.msg_type === "kernel_died") {
+          return conn.send({
+            type: "kernel_died",
+            exit_code: msg.content.exit_code
+          });
+        }
+        if (msg.msg_type === "status") {
+          return conn.send({
+            type: "status",
+            execution_state: msg.content.execution_state
+          });
+        }
+        return conn.send({
+          type: "output",
+          msg_id: msg.msg_id,
+          msg_type: msg.msg_type,
+          content: msg.content
+        });
+      }),
+      Stream_exports.runDrain
+    )
+  );
+  yield* conn.messages.pipe(
+    Stream_exports.mapEffect((raw) => {
+      const msg = raw;
+      const type = msg.type;
+      if (type === "execute") {
+        const msgId = msg.msg_id;
+        const code = msg.code;
+        return Effect_exports.tryPromise({
+          try: () => kernelManager.execute(bubbleId, code, msgId, cwd),
+          catch: (cause) => new AppError({ message: "kernel execute failed", cause })
+        }).pipe(
+          Effect_exports.catchAll(
+            (e) => conn.send({
+              type: "kernel_error",
+              message: e instanceof AppError ? e.message : String(e)
+            })
+          )
+        );
       }
-      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 !== WebSocket.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();
+      if (type === "interrupt") {
+        return Effect_exports.tryPromise({
+          try: () => kernelManager.interrupt(bubbleId),
+          catch: (cause) => new AppError({ message: "kernel interrupt failed", cause })
+        }).pipe(Effect_exports.catchAll(() => Effect_exports.void));
       }
-    });
-  };
-  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 === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "ping" }));
-    }
-  }, HEARTBEAT_INTERVAL);
+      return Effect_exports.void;
+    }),
+    Stream_exports.runDrain
+  );
+}).pipe(
+  Effect_exports.withSpan("ws.handleJupyter", { attributes: { bubbleId, cwd } })
+);
+var runJupyterHandler = (ws, bubbleId, cwd) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "jupyter");
+      yield* handleJupyter(conn, bubbleId, cwd);
+    })
+  ).pipe(
+    Effect_exports.catchTag(
+      "ValidationError",
+      (e) => Effect_exports.sync(() => ws.close(4400, e.reason))
+    ),
+    Effect_exports.catchAll(
+      (e) => Effect_exports.logError("[ws/jupyter]").pipe(
+        Effect_exports.annotateLogs("error", JSON.stringify(e))
+      )
+    )
+  );
+  const fiber = Effect_exports.runFork(program);
   ws.on("close", () => {
-    closed = true;
-    globalStateClients.delete(ws);
-    if (watcher) watcher.close();
-    clearInterval(heartbeat);
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
   });
-}
+};
+
+// src/lib/effect/terminalHandler.ts
+import { spawn, execSync } from "child_process";
+import * as nodePty from "node-pty";
+var HEARTBEAT5 = Schedule_exports.spaced("30 seconds");
 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();
+        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);
+        for (const cp of childPids) {
+          collect(cp);
+          descendants.push(cp);
         }
       } else {
-        result = execSync(`pgrep -P ${parentPid}`, { encoding: "utf-8", timeout: 3e3 }).trim();
+        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);
+        for (const cp of childPids) {
+          collect(cp);
+          descendants.push(cp);
         }
       }
     } catch {
@@ -481,595 +843,396 @@ function getDescendantPids(pid) {
   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 === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
+var makeCleanupRegistry = () => Effect_exports.gen(function* () {
+  const map = /* @__PURE__ */ new Map();
+  yield* Effect_exports.addFinalizer(
+    () => Effect_exports.sync(() => {
+      for (const f of map.values()) f();
+      map.clear();
+    })
+  );
+  return {
+    attach: (commandId, cleanup) => Effect_exports.sync(() => {
+      const old = map.get(commandId);
+      if (old) old();
+      map.set(commandId, cleanup);
+    }),
+    detach: (commandId) => Effect_exports.sync(() => {
+      const old = map.get(commandId);
+      if (old) {
+        old();
+        map.delete(commandId);
+      }
+    })
   };
-  const heartbeat = setInterval(() => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "ping" }));
+});
+var attachPipeListeners = (registry, send, commandId, child) => Effect_exports.gen(function* () {
+  const onStdout = (data) => {
+    Effect_exports.runFork(send({ type: "stdout", commandId, data: data.toString() }));
+  };
+  const onStderr = (data) => {
+    Effect_exports.runFork(send({ type: "stderr", commandId, data: data.toString() }));
+  };
+  const pid = child.pid;
+  const onClose = async (code) => {
+    const exitCode = code ?? 0;
+    Effect_exports.runFork(send({ type: "exit", commandId, code: exitCode }));
+    try {
+      await finalizeCommand(commandId, exitCode, pid);
+    } catch (e) {
+      Effect_exports.runFork(
+        Effect_exports.logError("[ws/terminal] finalize error").pipe(
+          Effect_exports.annotateLogs("error", String(e))
+        )
+      );
     }
-  }, 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;
+    Effect_exports.runFork(registry.detach(commandId));
+  };
+  const onError = async (error) => {
+    Effect_exports.runFork(send({ type: "error", commandId, error: error.message }));
     try {
-      msg = JSON.parse(raw.toString());
+      await finalizeCommand(commandId, 1, pid);
     } catch {
+    }
+    Effect_exports.runFork(registry.detach(commandId));
+  };
+  child.stdout?.on("data", onStdout);
+  child.stderr?.on("data", onStderr);
+  child.on("close", onClose);
+  child.on("error", onError);
+  yield* registry.attach(commandId, () => {
+    child.stdout?.off("data", onStdout);
+    child.stderr?.off("data", onStderr);
+    child.off("close", onClose);
+    child.off("error", onError);
+  });
+});
+var attachPtyListeners = (registry, send, commandId, pty) => Effect_exports.gen(function* () {
+  const dataDisposable = pty.onData((data) => {
+    Effect_exports.runFork(send({ type: "stdout", commandId, data }));
+  });
+  const ptyPid = pty.pid;
+  const exitDisposable = pty.onExit(async ({ exitCode }) => {
+    Effect_exports.runFork(send({ type: "exit", commandId, code: exitCode }));
+    try {
+      await finalizeCommand(commandId, exitCode, ptyPid);
+    } catch (e) {
+      Effect_exports.runFork(
+        Effect_exports.logError("[ws/terminal] finalize error").pipe(
+          Effect_exports.annotateLogs("error", String(e))
+        )
+      );
+    }
+    Effect_exports.runFork(registry.detach(commandId));
+  });
+  yield* registry.attach(commandId, () => {
+    dataDisposable.dispose();
+    exitDisposable.dispose();
+  });
+});
+var dispatchMessage = (msg, projectCwd, registry, send) => Effect_exports.sync(() => {
+  const type = msg.type;
+  if (type === "exec") {
+    const { commandId, command, cwd, tabId, env, usePty, cols, rows } = msg;
+    if (!commandId || !command || !cwd || !tabId) {
+      Effect_exports.runFork(
+        send({
+          type: "error",
+          commandId: commandId || "",
+          error: "Missing required parameters"
+        })
+      );
       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], {
+    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" });
+          }
+        );
+        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()
+        });
+        Effect_exports.runFork(send({ type: "pid", commandId, pid: ptyProcess.pid }));
+        Effect_exports.runFork(
+          attachPtyListeners(registry, send, 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: ptyProcess.pid,
-            process: dummyChild,
-            ptyProcess,
-            usePty: true,
+            pid: child.pid,
+            process: child,
             timestamp: (/* @__PURE__ */ new Date()).toISOString()
           });
-          send({ type: "pid", commandId, pid: ptyProcess.pid });
-          attachPtyListeners(commandId, ptyProcess);
+          Effect_exports.runFork(send({ type: "pid", commandId, pid: child.pid }));
+          Effect_exports.runFork(
+            attachPipeListeners(registry, send, commandId, child)
+          );
         } 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" });
-          }
+          Effect_exports.runFork(
+            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) {
+    } catch (e) {
+      Effect_exports.runFork(
+        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 {
-          cmd.ptyProcess.write(data);
+          process.kill(-cmd.pid, "SIGINT");
         } 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();
+            process.kill(cmd.pid, "SIGINT");
           } 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 });
-      if (cmd.usePty && cmd.ptyRingBuffer) {
-        const snap = cmd.ptyRingBuffer.snapshot();
-        if (snap) {
-          const replay = snap.slice(findSafeStart(snap));
-          if (replay) send({ type: "stdout", commandId, data: replay });
-        }
-      } else {
-        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) {
+      } else if (data === "" && cmd.pid) {
         try {
-          process.kill(p, "SIGTERM");
+          process.kill(cmd.pid, "SIGTSTP");
         } 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) {
+      } else if (data === "") {
         try {
-          cmd.ptyProcess.resize(cols, rows);
+          cmd.process.stdin?.end();
         } catch {
         }
+      } else if (cmd.process.stdin?.writable) {
+        cmd.process.stdin.write(data);
       }
-    } 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();
+  } else if (type === "attach") {
+    const { commandId } = msg;
+    const cmd = getRunningCommand(commandId);
+    if (!cmd) {
+      Effect_exports.runFork(
+        send({
+          type: "error",
+          commandId,
+          error: "Command not found or already finished"
+        })
+      );
+      return;
     }
-    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 {
+    Effect_exports.runFork(send({ type: "pid", commandId, pid: cmd.pid }));
+    if (cmd.usePty && cmd.ptyRingBuffer) {
+      const snap = cmd.ptyRingBuffer.snapshot();
+      if (snap) {
+        const replay = snap.slice(findSafeStart(snap));
+        if (replay)
+          Effect_exports.runFork(send({ type: "stdout", commandId, data: replay }));
       }
-    }
-  } 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 buffered = cmd.outputLines.join("\n") + (cmd.outputPartial ? "\n" + cmd.outputPartial : "");
+      if (buffered) {
+        Effect_exports.runFork(send({ type: "stdout", commandId, data: buffered }));
       }
-      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) {
+      Effect_exports.runFork(
+        attachPtyListeners(registry, send, commandId, cmd.ptyProcess)
+      );
+    } else {
+      Effect_exports.runFork(
+        attachPipeListeners(registry, send, 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 {
-        cmd.ptyProcess.write(data);
+        process.kill(p, "SIGTERM");
       } 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 === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "output", data }));
-    }
-  });
-  const unsubExit = addExitListener(entry.commandId, (code) => {
-    if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "exit", code }));
-      ws.close();
     }
-  });
-  const heartbeat = setInterval(() => {
-    if (ws.readyState === WebSocket.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 === WebSocket.OPEN) {
-        browser2.ws.close();
+    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 {
       }
-      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 !== WebSocket.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 });
+  } else if (type === "running") {
+    const commands = getRunningCommands(projectCwd);
+    if (commands.length === 0) {
+      const size = getRegistrySize();
+      const cwds = getAllProjectCwds();
+      Effect_exports.runFork(
+        Effect_exports.logWarning("[ws/terminal] running query: 0 commands").pipe(
+          Effect_exports.annotateLogs("projectCwd", projectCwd),
+          Effect_exports.annotateLogs("registryTotal", size),
+          Effect_exports.annotateLogs("cwds", cwds)
+        )
+      );
+    }
+    Effect_exports.runFork(send({ type: "running", commands }));
   }
-  return true;
-}
-function handleBrowser(ws, fullId) {
-  if (!fullId) {
-    ws.close(4400, "Missing fullId parameter");
-    return;
+});
+var handleTerminal = (conn, projectCwd) => Effect_exports.gen(function* () {
+  if (!projectCwd) {
+    return yield* Effect_exports.fail(
+      new ValidationError({ field: "projectCwd", reason: "missing" })
+    );
   }
-  const shortId = registerBrowser(fullId, ws);
-  ws.send(JSON.stringify({ type: "registered", shortId }));
-  const heartbeat = setInterval(() => {
-    if (ws.readyState === WebSocket.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);
-    }
-  });
+  yield* Effect_exports.logInfo("ws/terminal start").pipe(
+    Effect_exports.annotateLogs("projectCwd", projectCwd)
+  );
+  const registry = yield* makeCleanupRegistry();
+  yield* Effect_exports.forkScoped(
+    Effect_exports.repeat(conn.send({ type: "ping" }), HEARTBEAT5)
+  );
+  yield* conn.messages.pipe(
+    Stream_exports.mapEffect(
+      (raw) => dispatchMessage(
+        raw,
+        projectCwd,
+        registry,
+        conn.send
+      )
+    ),
+    Stream_exports.runDrain
+  );
+}).pipe(
+  Effect_exports.withSpan("ws.handleTerminal", { attributes: { projectCwd } })
+);
+var runTerminalHandler = (ws, projectCwd) => {
+  const program = Effect_exports.scoped(
+    Effect_exports.gen(function* () {
+      const conn = yield* fromWebSocket(ws, "terminal");
+      yield* handleTerminal(conn, projectCwd);
+    })
+  ).pipe(
+    Effect_exports.catchTag(
+      "ValidationError",
+      (e) => Effect_exports.sync(() => ws.close(4400, e.reason))
+    ),
+    Effect_exports.catchAll(
+      (e) => Effect_exports.logError("[ws/terminal]").pipe(
+        Effect_exports.annotateLogs("error", JSON.stringify(e))
+      )
+    )
+  );
+  const fiber = Effect_exports.runFork(program);
   ws.on("close", () => {
-    clearInterval(heartbeat);
-    unregisterBrowser(fullId);
+    Effect_exports.runFork(fiber.interruptAsFork(fiber.id()));
   });
-}
-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 === WebSocket.OPEN) {
-      ws.send(JSON.stringify(msg));
-    }
-  };
-  const heartbeat = setInterval(() => {
+};
+
+// src/lib/wsServer.ts
+var g_ws = globalThis;
+var globalStateClients = g_ws.__cockpitGlobalStateClients ?? (g_ws.__cockpitGlobalStateClients = /* @__PURE__ */ new Set());
+function broadcastToGlobalState(msg) {
+  const data = JSON.stringify(msg);
+  for (const ws of globalStateClients) {
     if (ws.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "ping" }));
-    }
-  }, HEARTBEAT_INTERVAL);
-  const { kernelManager } = await import("./server-K6XWP7DX.mjs");
-  try {
-    const instance = await kernelManager.getOrCreate(bubbleId, cwd);
-    if (instance.errorMessage) {
-      send({ type: "kernel_error", message: instance.errorMessage });
-    } else {
-      send({ type: "ready" });
+      ws.send(data);
     }
-  } 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);
+}
+var wss = g_ws.__cockpitWss ?? (() => {
+  const server = new WebSocketServer({ noServer: true });
+  g_ws.__cockpitWss = server;
+  server.on("connection", (ws, req) => {
+    const { pathname, query } = parse(req.url || "", true);
+    if (pathname === "/ws/watch") {
+      runFileWatchHandler(ws, query.cwd);
+    } else if (pathname === "/ws/global-state") {
+      globalStateClients.add(ws);
+      ws.on("close", () => globalStateClients.delete(ws));
+      runGlobalStateHandler(ws);
+    } else if (pathname === "/ws/terminal") {
+      runTerminalHandler(ws, query.projectCwd);
+    } else if (pathname === "/ws/browser") {
+      runBrowserHandler(ws, query.fullId);
+    } else if (pathname === "/ws/terminal-follow") {
+      runTerminalFollowHandler(ws, query.id);
+    } else if (pathname === "/ws/jupyter") {
+      runJupyterHandler(ws, query.bubbleId, query.cwd);
     }
   });
-  ws.on("close", () => {
-    closed = true;
-    clearInterval(heartbeat);
-    unsubscribe();
-  });
+  return server;
+})();
+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;
 }
 export {
   broadcastToGlobalState,
-  handleBrowserApi,
-  handleTerminalApi,
   handleUpgrade
 };