@sma1lboy/kobe 0.7.32 → 0.7.34

package/dist/web-ui/pty-server.mjs

@@ -3,8 +3,8 @@
  * bun, so the live terminals run here as a separate node process).
  *
  * Model: each web PTY tab is identified by a client-generated `tab` id. Its
- * PTY is spawned lazily on first attach (launch spec fetched from the bun
- * bridge by taskId + mode) and kept alive across WebSocket reconnects, so a
+ * PTY is spawned lazily on first attach (launch spec fetched from daemon web
+ * transport by taskId + mode) and kept alive across WebSocket reconnects, so a
  * page refresh re-attaches to the same process. Closing a tab (POST
  * /pty/close) kills its PTY.
  *
@@ -16,16 +16,17 @@
 import { createServer } from "node:http"
 import { spawn } from "node-pty"
 import { WebSocketServer } from "ws"
+import { allowedHostForBindHost, originAllowed } from "./origin-policy.mjs"
 import { createScrollback } from "./pty-scrollback.mjs"
+import { createPtySessionManager } from "./pty-session-lifecycle.mjs"
 
 const PORT = Number.parseInt(process.env.KOBE_PTY_PORT ?? "5175", 10)
-const BRIDGE_PORT = Number.parseInt(process.env.KOBE_BRIDGE_PORT ?? "5174", 10)
+const DAEMON_WEB_PORT = Number.parseInt(process.env.KOBE_DAEMON_WEB_PORT ?? "5174", 10)
 const SCROLLBACK_CAP = 256 * 1024 // bytes of recent output replayed on (re)attach
 const HEALTH_PATH = "/__kobe_web"
 const HEALTH_MARKER = "kobe-web"
-
-/** tabId → { pty, buffer, sockets } */
-const tabs = new Map()
+const HOST = process.env.KOBE_WEB_HOST?.trim() || "127.0.0.1"
+const ALLOWED_HOST = allowedHostForBindHost(HOST)
 
 function ptyEnv() {
   const { NO_COLOR: _noColor, ...env } = process.env
@@ -39,78 +40,19 @@ function ptyEnv() {
 
 async function fetchSpec(taskId, mode) {
   const path = mode === "shell" ? "/api/terminal-spec" : "/api/engine-spec"
-  const res = await fetch(`http://localhost:${BRIDGE_PORT}${path}?taskId=${encodeURIComponent(taskId)}`)
+  const res = await fetch(`http://localhost:${DAEMON_WEB_PORT}${path}?taskId=${encodeURIComponent(taskId)}`)
   const json = await res.json()
   if (!res.ok || json.error) throw new Error(json.error ?? `engine-spec failed (${res.status})`)
   return json // { cwd, command: string[] }
 }
 
-function spawnTab(tabId, spec, cols, rows) {
-  const [cmd, ...args] = spec.command
-  const pty = spawn(cmd, args, {
-    name: "xterm-256color",
-    cols,
-    rows,
-    cwd: spec.cwd,
-    env: ptyEnv(),
-  })
-  // Scrollback is a bounded ring of chunks, not a single growing string: the
-  // old `(buffer + data).slice(-CAP)` re-flattened ~256KB on EVERY chunk once
-  // the cap was reached (quadratic during heavy streaming). `push` is O(chunk);
-  // the string is materialized only on (re)attach replay.
-  const entry = { pty, scrollback: createScrollback(SCROLLBACK_CAP), sockets: new Set() }
-  pty.onData((data) => {
-    entry.scrollback.push(data)
-    for (const ws of entry.sockets) if (ws.readyState === ws.OPEN) ws.send(data)
-  })
-  pty.onExit(() => {
-    for (const ws of entry.sockets) if (ws.readyState === ws.OPEN) ws.close(1000, "engine exited")
-    tabs.delete(tabId)
-  })
-  tabs.set(tabId, entry)
-  return entry
-}
-
-function closeTab(tabId) {
-  const entry = tabs.get(tabId)
-  if (!entry) return false
-  try {
-    entry.pty.kill()
-  } catch {
-    /* already gone */
-  }
-  tabs.delete(tabId)
-  return true
-}
-
-// In-flight spawns, keyed by tabId. `fetchSpec` is async, so a naive
-// check-then-`spawnTab` lets two concurrent attaches for the SAME tab (React
-// StrictMode double-mount, a fast reconnect racing the first attach, or a
-// board /pty/send racing a WS open) both pass the `!entry` check and both
-// spawn — the second `tabs.set` orphans the first PTY (no longer in `tabs`, so
-// /pty/close and shutdown can never kill it, and its onExit deletes the live
-// entry's mapping). Coalescing onto one promise per tabId makes spawn
-// single-flight, so concurrent attaches share exactly one PTY.
-const pendingSpawns = new Map()
-
-async function ensureTab(tabId, taskId, mode, cols, rows) {
-  const existing = tabs.get(tabId)
-  if (existing) return existing
-  const inflight = pendingSpawns.get(tabId)
-  if (inflight) return inflight
-  const p = (async () => {
-    const spec = await fetchSpec(taskId, mode)
-    // A prior spawn may have completed (and not yet been closed) while we
-    // awaited the spec — reuse it rather than spawning a duplicate.
-    return tabs.get(tabId) ?? spawnTab(tabId, spec, cols, rows)
-  })()
-  pendingSpawns.set(tabId, p)
-  try {
-    return await p
-  } finally {
-    pendingSpawns.delete(tabId)
-  }
-}
+const ptySessions = createPtySessionManager({
+  fetchSpec,
+  spawnPty: spawn,
+  createScrollback,
+  scrollbackCap: SCROLLBACK_CAP,
+  env: ptyEnv,
+})
 
 const server = createServer((req, res) => {
   const url = new URL(req.url ?? "/", "http://localhost")
@@ -132,8 +74,7 @@ const server = createServer((req, res) => {
     // Sending text DRIVES the engine like a keyboard, so unlike /pty/close
     // (best-effort kill) this holds the same origin policy as the WS attach:
     // localhost pages or non-browser clients only.
-    const origin = req.headers.origin
-    if (origin && !LOCAL_ORIGIN.test(origin)) {
+    if (!originAllowed(req.headers.origin, { allowedHost: ALLOWED_HOST })) {
       res.writeHead(403)
       res.end()
       return
@@ -162,53 +103,24 @@ const server = createServer((req, res) => {
         respond(400, { sent: false, error: "tab and text are required" })
         return
       }
-      let entry = tabs.get(tab)
-      let spawned = false
-      if (!entry && typeof taskId === "string" && taskId) {
+      let result
+      try {
         // Spawn-on-send: a board action can fire without the terminal ever
         // opening — output lands in the scrollback ring for the next attach.
-        // ensureTab coalesces with any concurrent WS attach for the same tab.
-        try {
-          entry = await ensureTab(tab, taskId, "engine", 80, 24)
-          spawned = true
-        } catch (err) {
-          respond(500, { sent: false, error: `failed to start engine: ${err?.message ?? err}` })
-          return
-        }
+        result = await ptySessions.sendText({
+          tabId: tab,
+          taskId: typeof taskId === "string" && taskId ? taskId : null,
+          text,
+        })
+      } catch (err) {
+        respond(500, { sent: false, error: `failed to start engine: ${err?.message ?? err}` })
+        return
       }
-      if (!entry) {
+      if (!result.sent) {
         respond(404, { sent: false, error: "no such tab" })
         return
       }
-      // Same submit contract as the composer / tmux pasteAndSubmit:
-      // bracketed paste so a multi-line prompt arrives as ONE paste, then
-      // Enter. A freshly spawned engine gets a grace delay so the paste
-      // isn't eaten by its startup. The Enter MUST land in a separate,
-      // later write: written back-to-back it coalesces into the same tty
-      // chunk as the paste and claude treats it as paste content — the
-      // text sits in the composer and never submits. (tmux pasteAndSubmit
-      // gets this separation for free from its two commands; the web
-      // composer from its two WS messages.)
-      const target = entry
-      setTimeout(
-        () => {
-          try {
-            target.pty.write(`\x1b[200~${text}\x1b[201~`)
-          } catch {
-            /* engine died between spawn and paste — next attach shows why */
-            return
-          }
-          setTimeout(() => {
-            try {
-              target.pty.write("\r")
-            } catch {
-              /* same: best-effort */
-            }
-          }, 150)
-        },
-        spawned ? 2500 : 0,
-      )
-      respond(200, { sent: true, spawned })
+      respond(200, { sent: true, spawned: result.spawned })
     })
     return
   }
@@ -217,8 +129,7 @@ const server = createServer((req, res) => {
     // DoS the session (tab ids are client-generated/observable), so hold the
     // same origin policy as /pty/send and the WS attach: localhost pages or
     // non-browser clients (no Origin) only.
-    const origin = req.headers.origin
-    if (origin && !LOCAL_ORIGIN.test(origin)) {
+    if (!originAllowed(req.headers.origin, { allowedHost: ALLOWED_HOST })) {
       res.writeHead(403)
       res.end()
       return
@@ -234,7 +145,7 @@ const server = createServer((req, res) => {
       } catch {
         /* ignore */
       }
-      const ok = tab ? closeTab(tab) : false
+      const ok = tab ? ptySessions.closeSession(tab) : false
       res.writeHead(200, {
         "content-type": "application/json",
         "access-control-allow-origin": "*",
@@ -248,15 +159,14 @@ const server = createServer((req, res) => {
 })
 
 // A PTY WS is arbitrary command exec in the worktree, so reject cross-origin
-// upgrades: a browser sends an Origin header, and only localhost pages may
-// attach (defends a malicious local page / DNS-rebinding even on the loopback
-// bind). Non-browser clients (no Origin) are allowed — there's no browser to
-// forge their request.
-const LOCAL_ORIGIN = /^https?:\/\/(localhost|127\.0\.0\.1|\[::1\])(:\d+)?$/
+// upgrades: a browser sends an Origin header, and only loopback pages (or the
+// deliberately configured LAN host) may attach. This defends a malicious local
+// page / DNS-rebinding even on the loopback bind. Non-browser clients (no
+// Origin) are allowed — there's no browser to forge their request.
 const wss = new WebSocketServer({
   server,
   path: "/pty",
-  verifyClient: ({ origin }) => !origin || LOCAL_ORIGIN.test(origin),
+  verifyClient: ({ origin }) => originAllowed(origin, { allowedHost: ALLOWED_HOST }),
 })
 
 wss.on("connection", (ws, req) => {
@@ -273,10 +183,9 @@ wss.on("connection", (ws, req) => {
   }
 
   void (async () => {
-    let entry
     try {
       // Single-flight spawn: concurrent attaches for this tab share one PTY.
-      entry = await ensureTab(tabId, taskId, mode, cols, rows)
+      await ptySessions.attachSocket({ ws, tabId, taskId, mode, cols, rows })
     } catch (err) {
       if (ws.readyState === ws.OPEN) {
         ws.send(`\r\nfailed to start ${mode}: ${err?.message ?? err}\r\n`)
@@ -284,69 +193,17 @@ wss.on("connection", (ws, req) => {
       }
       return
     }
-
-    // Snapshot the scrollback BEFORE joining the live fan-out. If a chunk
-    // arrives between `sockets.add` and the replay it would be sent live (the
-    // socket is already in the set) AND included in the replay — the browser
-    // writes the same bytes twice, briefly garbling the screen on (re)attach.
-    // Capturing the replay first, then adding the socket, makes attach
-    // exactly-once: the snapshot is everything-so-far, and anything after it
-    // arrives only via the live path.
-    const replay = entry.scrollback.length() > 0 ? entry.scrollback.replay() : ""
-    entry.sockets.add(ws)
-    if (replay && ws.readyState === ws.OPEN) ws.send(replay)
-    // The PTY can exit between spawn/attach and any op below; node-pty throws
-    // on resize/write against a dead handle, and this sidecar has no
-    // uncaughtException net (unlike the daemon) — an unguarded throw in a `ws`
-    // callback kills the whole pty-server process. Guard every pty op.
-    const safePty = (fn) => {
-      if (!tabs.has(tabId)) return
-      try {
-        fn(entry.pty)
-      } catch {
-        /* engine died — its onExit already closed the sockets */
-      }
-    }
-    safePty((pty) => pty.resize(cols, rows))
-
-    ws.on("message", (raw) => {
-      const text = raw.toString()
-      if (text.startsWith("{")) {
-        try {
-          const msg = JSON.parse(text)
-          if (msg && msg.type === "resize" && Number.isFinite(msg.cols) && Number.isFinite(msg.rows)) {
-            safePty((pty) => pty.resize(Math.max(1, msg.cols | 0), Math.max(1, msg.rows | 0)))
-            return
-          }
-        } catch {
-          /* fall through to raw write */
-        }
-      }
-      safePty((pty) => pty.write(text))
-    })
-
-    ws.on("close", () => {
-      entry.sockets.delete(ws)
-      // Keep the PTY alive for reconnects; it's killed only via /pty/close.
-    })
   })()
 })
 
 // Bind loopback by default — a PTY is an arbitrary shell/engine in the
 // worktree, so it must never listen on all interfaces. KOBE_WEB_HOST overrides.
-const HOST = process.env.KOBE_WEB_HOST?.trim() || "127.0.0.1"
 server.listen(PORT, HOST, () => {
-  process.stdout.write(`kobe pty-server listening on ${HOST}:${PORT} (bridge :${BRIDGE_PORT})\n`)
+  process.stdout.write(`kobe pty-server listening on ${HOST}:${PORT} (daemon-web :${DAEMON_WEB_PORT})\n`)
 })
 
 const shutdown = () => {
-  for (const [, entry] of tabs) {
-    try {
-      entry.pty.kill()
-    } catch {
-      /* ignore */
-    }
-  }
+  ptySessions.shutdown()
   wss.close()
   server.close()
   process.exit(0)

package/dist/web-ui/pty-session-lifecycle.mjs

@@ -0,0 +1,177 @@
+/**
+ * PTY session lifecycle manager for the web sidecar.
+ *
+ * The HTTP/WebSocket server is transport glue; this module owns the deeper
+ * lifecycle state for tab-keyed PTY sessions: single-flight spawn, attach,
+ * scrollback replay, resize/input, close, process-exit cleanup, and shutdown.
+ */
+
+const DEFAULT_SUBMIT_DELAYS = {
+  spawnedPasteMs: 2500,
+  existingPasteMs: 0,
+  enterMs: 150,
+}
+
+export function createPtySessionManager({
+  fetchSpec,
+  spawnPty,
+  createScrollback,
+  scrollbackCap,
+  env,
+  setTimeoutFn = setTimeout,
+  submitDelays = DEFAULT_SUBMIT_DELAYS,
+}) {
+  /** @type {Map<string, { pty: any, scrollback: ReturnType<createScrollback>, sockets: Set<any> }>} */
+  const sessions = new Map()
+  /** @type {Map<string, Promise<any>>} */
+  const pendingSpawns = new Map()
+
+  function spawnSession(tabId, spec, cols, rows) {
+    const [cmd, ...args] = spec.command
+    const spawnEnv = typeof env === "function" ? env() : env
+    const pty = spawnPty(cmd, args, {
+      name: "xterm-256color",
+      cols,
+      rows,
+      cwd: spec.cwd,
+      env: spawnEnv,
+    })
+    const entry = {
+      pty,
+      scrollback: createScrollback(scrollbackCap),
+      sockets: new Set(),
+    }
+    pty.onData((data) => {
+      entry.scrollback.push(data)
+      for (const ws of entry.sockets) {
+        if (ws.readyState === ws.OPEN) ws.send(data)
+      }
+    })
+    pty.onExit(() => {
+      for (const ws of entry.sockets) {
+        if (ws.readyState === ws.OPEN) ws.close(1000, "engine exited")
+      }
+      if (sessions.get(tabId) === entry) sessions.delete(tabId)
+    })
+    sessions.set(tabId, entry)
+    return entry
+  }
+
+  async function ensureSession(tabId, taskId, mode, cols, rows) {
+    const existing = sessions.get(tabId)
+    if (existing) return existing
+    const inflight = pendingSpawns.get(tabId)
+    if (inflight) return inflight
+    const p = (async () => {
+      const spec = await fetchSpec(taskId, mode)
+      return sessions.get(tabId) ?? spawnSession(tabId, spec, cols, rows)
+    })()
+    pendingSpawns.set(tabId, p)
+    try {
+      return await p
+    } finally {
+      pendingSpawns.delete(tabId)
+    }
+  }
+
+  function safePty(tabId, entry, fn) {
+    if (sessions.get(tabId) !== entry) return
+    try {
+      fn(entry.pty)
+    } catch {
+      /* engine died — its onExit closes sockets and clears the entry */
+    }
+  }
+
+  async function attachSocket({ ws, tabId, taskId, mode, cols, rows }) {
+    const entry = await ensureSession(tabId, taskId, mode, cols, rows)
+    const replay = entry.scrollback.length() > 0 ? entry.scrollback.replay() : ""
+    entry.sockets.add(ws)
+    if (replay && ws.readyState === ws.OPEN) ws.send(replay)
+    safePty(tabId, entry, (pty) => pty.resize(cols, rows))
+
+    ws.on("message", (raw) => {
+      const text = raw.toString()
+      if (text.startsWith("{")) {
+        try {
+          const msg = JSON.parse(text)
+          if (msg && msg.type === "resize" && Number.isFinite(msg.cols) && Number.isFinite(msg.rows)) {
+            safePty(tabId, entry, (pty) => pty.resize(Math.max(1, msg.cols | 0), Math.max(1, msg.rows | 0)))
+            return
+          }
+        } catch {
+          /* fall through to raw write */
+        }
+      }
+      safePty(tabId, entry, (pty) => pty.write(text))
+    })
+
+    ws.on("close", () => {
+      entry.sockets.delete(ws)
+    })
+
+    return entry
+  }
+
+  function closeSession(tabId) {
+    const entry = sessions.get(tabId)
+    if (!entry) return false
+    try {
+      entry.pty.kill()
+    } catch {
+      /* already gone */
+    }
+    if (sessions.get(tabId) === entry) sessions.delete(tabId)
+    return true
+  }
+
+  async function sendText({ tabId, taskId, text }) {
+    let entry = sessions.get(tabId)
+    let spawned = false
+    if (!entry && taskId) {
+      entry = await ensureSession(tabId, taskId, "engine", 80, 24)
+      spawned = true
+    }
+    if (!entry) return { sent: false, spawned: false, missing: true }
+
+    const target = entry
+    const pasteDelay = spawned ? submitDelays.spawnedPasteMs : submitDelays.existingPasteMs
+    setTimeoutFn(() => {
+      try {
+        target.pty.write(`\x1b[200~${text}\x1b[201~`)
+      } catch {
+        return
+      }
+      setTimeoutFn(() => {
+        try {
+          target.pty.write("\r")
+        } catch {
+          /* best-effort */
+        }
+      }, submitDelays.enterMs)
+    }, pasteDelay)
+    return { sent: true, spawned }
+  }
+
+  function shutdown() {
+    for (const entry of sessions.values()) {
+      try {
+        entry.pty.kill()
+      } catch {
+        /* ignore */
+      }
+    }
+    sessions.clear()
+    pendingSpawns.clear()
+  }
+
+  return {
+    attachSocket,
+    closeSession,
+    ensureSession,
+    sendText,
+    shutdown,
+    sessionCount: () => sessions.size,
+    pendingSpawnCount: () => pendingSpawns.size,
+  }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@sma1lboy/kobe",
-  "version": "0.7.32",
+  "version": "0.7.34",
   "description": "TUI orchestrator for Claude Code (codename)",
   "type": "module",
   "packageManager": "bun@1.3.13",
   "bin": {
     "kobe": "dist/cli/index.js"
   },
-  "files": ["dist", "README.md", "LICENSE"],
+  "files": ["dist/cli", "dist/web-ui", "dist/*.wav", "README.md", "LICENSE"],
   "publishConfig": {
     "access": "public"
   },
@@ -27,7 +27,9 @@
     "dev": "env KOBE_DEV=1 bun --preload @opentui/solid/preload --conditions=browser ./src/cli/index.ts",
     "dev:sandbox": "mkdir -p .dev-sandbox/home && env KOBE_DEV=1 KOBE_HOME_DIR=$PWD/.dev-sandbox/home KOBE_TMUX_SOCKET=kobe-sandbox bun --preload @opentui/solid/preload --conditions=browser ./src/cli/index.ts",
     "dev:sandbox:reset": "env KOBE_TMUX_SOCKET=kobe-sandbox bun ./src/cli/index.ts kill-sessions",
+    "dev:version": "bash ../../scripts/dev-version.sh",
     "build": "bun run scripts/build.ts",
+    "build:with-web": "bun run build",
     "compile": "bun run scripts/compile.ts",
     "typecheck": "tsc --noEmit",
     "test": "bun run test:fast && bun run test:socket",
@@ -45,7 +47,6 @@
     "@ansi-tools/parser": "^1.0.15",
     "@opentui/core": "0.2.4",
     "@opentui/solid": "0.2.4",
-    "node-pty": "^1.1.0",
     "ws": "^8.18.0",
     "solid-js": "1.9.12"
   },
@@ -57,6 +58,7 @@
     "@types/node": "25.6.2",
     "knip": "^6.14.2",
     "kobe-web": "workspace:*",
+    "node-pty": "^1.1.0",
     "typescript": "5.8.2",
     "vitest": "2.1.9"
   },