@newsails/veil-studio 1.0.1 → 2.0.0

package/server/utils/orchestration-graph.js

@@ -0,0 +1,359 @@
+'use strict'
+
+const AGENT_TOOLS = new Set(['agent_spawn', 'agent_message', 'agent_send'])
+const PENDING_TTL = 60_000 // 60s timeout for pending tool results
+
+class OrchestrationGraph {
+  constructor() {
+    this._nodes = new Map()   // sessionId → { id, title, agentName, instance_name, parent_session_id, status }
+    this._edges = new Map()   // `${from}:${to}:${type}` → { from, to, type, count }
+    this._pending = new Map() // toolCallId → { sessionId, toolName, agentName, ts }
+    this._built = false
+    this._io = null
+  }
+
+  setIO(io) { this._io = io }
+
+  _emitDeltas(deltas) {
+    if (this._io && deltas.length) {
+      this._io.to('board').emit('orchestration:delta', deltas)
+    }
+  }
+
+  // PR-9 item 3a: `_ensureNode` now accepts optional `extras` carrying
+  // `instance_name` and `parent_session_id`. The first invocation creates the
+  // node + emits a `node:add` delta; later invocations BACKFILL missing extras
+  // (so a spawn-message that arrived first can be stamped with instance_name
+  // / parent_session_id once the session.created event lands). We return a
+  // `node:update` delta in the backfill case so the client store refreshes.
+  _ensureNode(sessionId, title, agentName, status, extras = {}) {
+    const existing = this._nodes.get(sessionId)
+    if (existing) {
+      let changed = false
+      if (extras.instance_name !== undefined && existing.instance_name == null && extras.instance_name != null) {
+        existing.instance_name = extras.instance_name
+        changed = true
+      }
+      if (extras.parent_session_id !== undefined && existing.parent_session_id == null && extras.parent_session_id != null) {
+        existing.parent_session_id = extras.parent_session_id
+        changed = true
+      }
+      if (agentName && !existing.agentName) {
+        existing.agentName = agentName
+        changed = true
+      }
+      if (title && (existing.title === 'Untitled' || !existing.title)) {
+        existing.title = title
+        changed = true
+      }
+      return changed ? { type: 'node:update', data: { ...existing } } : null
+    }
+    const node = {
+      id:                 sessionId,
+      title:              title || 'Untitled',
+      agentName:          agentName || '',
+      instance_name:      extras.instance_name ?? null,
+      parent_session_id:  extras.parent_session_id ?? null,
+      status:             status || 'active',
+    }
+    this._nodes.set(sessionId, node)
+    return { type: 'node:add', data: node }
+  }
+
+  _addOrUpdateEdge(from, to, type) {
+    const key = `${from}:${to}:${type}`
+    const existing = this._edges.get(key)
+    if (existing) {
+      existing.count++
+      return { type: 'edge:update', data: { ...existing } }
+    }
+    const edge = { from, to, type, count: 1 }
+    this._edges.set(key, edge)
+    return { type: 'edge:add', data: edge }
+  }
+
+  // PR-9 Miss1 (M4 critique): Veil's `core/router.js:416` emits
+  // `{type: 'session.created', sessionId, agentName, event: { mode,
+  // parentSessionId, instanceName, timestamp }}` whenever a sub-session is
+  // created (agent_spawn / agent_message). Studio previously dropped this
+  // event so freshly-spawned sub-sessions had no `instance_name` /
+  // `parent_session_id` until the next `/sessions` rebuild on reconnect.
+  // This handler live-stamps the graph node and (when the parent is already
+  // known) ensures a `spawn` edge so the popup tree shows accurate
+  // hierarchy immediately. Idempotent — replays update the same node.
+  handleSessionCreated({ sessionId, agentName, instance_name, parent_session_id }) {
+    if (!sessionId) return null
+    const deltas = []
+    const nd = this._ensureNode(sessionId, null, agentName || '', 'active', {
+      instance_name:     instance_name ?? null,
+      parent_session_id: parent_session_id ?? null,
+    })
+    if (nd) deltas.push(nd)
+    if (parent_session_id) {
+      // Stub-create the parent if missing so the spawn edge can always be
+      // emitted. A top-level parent created in this Studio session never
+      // received its own session.created event (Veil only fires it for
+      // sub-sessions), so without this stub the edge would be dropped and
+      // getSubgraph BFS in the client would not reach the new child.
+      // Stub agentName is backfilled by processMessage when the agent_spawn
+      // tool result arrives via the parent's SSE; title only refreshes on
+      // user rename (veil:patch-session) or next bulk init at restart.
+      const parentStub = this._ensureNode(parent_session_id, null, '', 'active')
+      if (parentStub) deltas.push(parentStub)
+      // Guard with _edges.has() so a duplicate fire from processMessage's
+      // tool-result branch (lines 159) does not inflate count past 1.
+      const edgeKey = `${parent_session_id}:${sessionId}:spawn`
+      if (!this._edges.has(edgeKey)) {
+        deltas.push(this._addOrUpdateEdge(parent_session_id, sessionId, 'spawn'))
+      }
+    }
+    if (deltas.length) this._emitDeltas(deltas)
+    return deltas.length ? deltas : null
+  }
+
+  // Process a single message — handles both assistant (tool_calls) and tool (results)
+  processMessage(sessionId, message, agentName) {
+    const deltas = []
+
+    if (message.role === 'assistant' && Array.isArray(message.tool_calls)) {
+      for (const tc of message.tool_calls) {
+        const name = tc.function?.name || tc.name || ''
+        if (!AGENT_TOOLS.has(name)) continue
+
+        if (name === 'agent_spawn') {
+          // PR-9 item 3a: agent_spawn args may carry `instance_name`. Pull it
+          // out so the new sub-node is stamped immediately, before any
+          // session.created / GET /sessions backfill races.
+          const spawnArgs = this._extractArgs(tc)
+          const instanceName = spawnArgs?.instance_name ?? null
+
+          // Check if result is already available (history path)
+          const resultId = this._extractSessionIdFromResult(tc.result)
+          if (resultId) {
+            const nd = this._ensureNode(sessionId, null, agentName, 'active')
+            if (nd) deltas.push(nd)
+            const cd = this._ensureNode(resultId, null, '', 'active', {
+              instance_name:     instanceName,
+              parent_session_id: sessionId,
+            })
+            if (cd) deltas.push(cd)
+            const edgeKey = `${sessionId}:${resultId}:spawn`
+            if (!this._edges.has(edgeKey)) {
+              deltas.push(this._addOrUpdateEdge(sessionId, resultId, 'spawn'))
+            }
+          } else if (tc.id) {
+            // Streaming path: result not yet available, store pending
+            this._pending.set(tc.id, { sessionId, toolName: name, agentName, ts: Date.now(), instanceName })
+          }
+        } else {
+          // agent_message / agent_send — target session ID is in the arguments
+          const args = this._extractArgs(tc)
+          const targetId = args ? (args.session_id || args.sessionId || null) : null
+          if (targetId) {
+            const nd = this._ensureNode(sessionId, null, agentName, 'active')
+            if (nd) deltas.push(nd)
+            const td = this._ensureNode(targetId, null, '', 'active')
+            if (td) deltas.push(td)
+            deltas.push(this._addOrUpdateEdge(sessionId, targetId, 'message'))
+          }
+        }
+      }
+    }
+
+    // Tool result — resolve pending agent_spawn
+    if (message.role === 'tool' && message.tool_call_id) {
+      const pending = this._pending.get(message.tool_call_id)
+      if (pending && pending.toolName === 'agent_spawn') {
+        this._pending.delete(message.tool_call_id)
+        const spawnedId = this._extractSessionIdFromResult(message.content)
+        if (spawnedId) {
+          const nd = this._ensureNode(pending.sessionId, null, pending.agentName, 'active')
+          if (nd) deltas.push(nd)
+          const cd = this._ensureNode(spawnedId, null, '', 'active', {
+            instance_name:     pending.instanceName ?? null,
+            parent_session_id: pending.sessionId,
+          })
+          if (cd) deltas.push(cd)
+          // Guard against handleSessionCreated having already added this edge
+          // — spawn is one-shot per parent/child pair, count must stay at 1.
+          const edgeKey = `${pending.sessionId}:${spawnedId}:spawn`
+          if (!this._edges.has(edgeKey)) {
+            deltas.push(this._addOrUpdateEdge(pending.sessionId, spawnedId, 'spawn'))
+          }
+        }
+      }
+    }
+
+    return deltas.length ? deltas : null
+  }
+
+  // Process full message history for a session (startup scan)
+  processSessionHistory(sessionId, messages, agentName) {
+    const deltas = []
+    for (const msg of messages) {
+      const d = this.processMessage(sessionId, msg, agentName)
+      if (d) deltas.push(...d)
+    }
+    return deltas.length ? deltas : null
+  }
+
+  handleSessionDeleted(sessionId) {
+    const deltas = []
+    if (this._nodes.has(sessionId)) {
+      this._nodes.delete(sessionId)
+      deltas.push({ type: 'node:remove', data: { id: sessionId } })
+    }
+    // Collect keys first to avoid deleting during iteration
+    const toRemove = []
+    for (const [key, edge] of this._edges) {
+      if (edge.from === sessionId || edge.to === sessionId) {
+        toRemove.push(key)
+        deltas.push({ type: 'edge:remove', data: edge })
+      }
+    }
+    for (const key of toRemove) this._edges.delete(key)
+    return deltas.length ? deltas : null
+  }
+
+  handleSessionUpdated(sessionId, meta) {
+    const node = this._nodes.get(sessionId)
+    if (!node) return null
+    let changed = false
+    if (meta.title && meta.title !== node.title) { node.title = meta.title; changed = true }
+    if (meta.status && meta.status !== node.status) { node.status = meta.status; changed = true }
+    if (meta.agent_name && meta.agent_name !== node.agentName) { node.agentName = meta.agent_name; changed = true }
+    if (meta.instance_name !== undefined && meta.instance_name !== node.instance_name) {
+      node.instance_name = meta.instance_name
+      changed = true
+    }
+    if (meta.parent_session_id !== undefined && meta.parent_session_id !== node.parent_session_id) {
+      node.parent_session_id = meta.parent_session_id
+      changed = true
+    }
+    return changed ? [{ type: 'node:update', data: { ...node } }] : null
+  }
+
+  getFullGraph() {
+    return {
+      nodes: Object.fromEntries(this._nodes),
+      edges: [...this._edges.values()],
+    }
+  }
+
+  hasOrchestration(sessionId) {
+    return this._nodes.has(sessionId)
+  }
+
+  // Reset graph state (used before rebuild on reconnect)
+  reset() {
+    this._nodes.clear()
+    this._edges.clear()
+    this._pending.clear()
+    this._built = false
+  }
+
+  // Periodic cleanup of stale pending entries
+  cleanupPending() {
+    const now = Date.now()
+    for (const [id, entry] of this._pending) {
+      if (now - entry.ts > PENDING_TTL) this._pending.delete(id)
+    }
+  }
+
+  _extractArgs(tc) {
+    try {
+      const raw = tc.function?.arguments ?? tc.args
+      return typeof raw === 'string' ? JSON.parse(raw) : (raw || {})
+    } catch { return null }
+  }
+
+  _extractSessionIdFromArgs(tc) {
+    const args = this._extractArgs(tc)
+    if (!args) return null
+    return args.session_id || args.sessionId || null
+  }
+
+  _extractSessionIdFromResult(content) {
+    if (!content) return null
+    try {
+      const result = typeof content === 'string' ? JSON.parse(content) : content
+      if (typeof result === 'object' && result !== null) {
+        return result.session_id || result.sessionId || null
+      }
+      return null
+    } catch {
+      return null
+    }
+  }
+}
+
+const _graph = new OrchestrationGraph()
+
+// Cleanup pending entries every 30s
+setInterval(() => _graph.cleanupPending(), 30_000)
+
+async function initOrchestrationGraph(veilGet) {
+  // Reset before rebuild (handles reconnect without inflating counts)
+  _graph.reset()
+  try {
+    const sessRes = await veilGet('/sessions?limit=10000')
+    const sessions = Array.isArray(sessRes) ? sessRes : (sessRes.sessions || sessRes.data || [])
+
+    // Bootstrap nodes from /sessions — provides title, instance_name,
+    // parent_session_id, agent_name, status, and includes lone top-level
+    // sessions that /orchestration/graph omits.
+    for (const session of sessions) {
+      _graph._ensureNode(session.id, session.title || 'Untitled', session.agent_name || '', session.status || 'active', {
+        instance_name:     session.instance_name     ?? null,
+        parent_session_id: session.parent_session_id ?? null,
+      })
+    }
+
+    // Fetch edges from /orchestration/graph (single bulk call replacing N+1 messages loop)
+    let graphEdges = []
+    let graphNodes = []
+    try {
+      const graphRes = await veilGet('/orchestration/graph?depth=50')
+      graphEdges = Array.isArray(graphRes?.edges) ? graphRes.edges : []
+      graphNodes = Array.isArray(graphRes?.nodes) ? graphRes.nodes : []
+    } catch (err) {
+      console.warn(`[orchestration] GET /orchestration/graph failed, proceeding with empty edges: ${err.message}`)
+    }
+
+    // Defensive: ensure every node referenced by the graph API has a row in _nodes
+    for (const node of graphNodes) {
+      if (node.sessionId && !_graph._nodes.has(node.sessionId)) {
+        _graph._ensureNode(node.sessionId, null, node.agentName || '', node.status || 'active', {
+          instance_name:     null,
+          parent_session_id: node.parentSessionId ?? null,
+        })
+      }
+    }
+
+    // Adapt edges from /orchestration/graph into the local graph.
+    // Use _edges.has() guard before calling _addOrUpdateEdge so that a live WS
+    // delta that already created the edge during init isn't double-incremented.
+    for (const e of graphEdges) {
+      if (e.type === 'spawn' && e.parentSessionId && e.childSessionId) {
+        const key = `${e.parentSessionId}:${e.childSessionId}:spawn`
+        if (!_graph._edges.has(key)) {
+          _graph._addOrUpdateEdge(e.parentSessionId, e.childSessionId, 'spawn')
+        }
+      } else if (e.type === 'message' && e.fromSessionId && e.targetSessionId) {
+        const key = `${e.fromSessionId}:${e.targetSessionId}:message`
+        if (!_graph._edges.has(key)) {
+          _graph._addOrUpdateEdge(e.fromSessionId, e.targetSessionId, 'message')
+        }
+        const edge = _graph._edges.get(key)
+        if (edge && typeof e.messageCount === 'number') edge.count = e.messageCount
+      }
+    }
+
+    _graph._built = true
+    console.log(`[orchestration] Graph built: ${_graph._nodes.size} nodes, ${_graph._edges.size} edges (sessions API + graph API)`)
+  } catch (err) {
+    console.warn(`[orchestration] Build failed, starting empty: ${err.message}`)
+  }
+}
+
+module.exports = { orchestrationGraph: _graph, initOrchestrationGraph }

package/server/utils/server-app.js

@@ -0,0 +1,23 @@
+'use strict'
+
+/**
+ * Express app and httpServer singleton — mirrors the socket-io.js pattern.
+ * Call setApp(app) and setHttpServer(server) from index.js after creation.
+ */
+
+let _app = null
+let _httpServer = null
+
+function setApp(app) { _app = app }
+function getApp() {
+  if (!_app) throw new Error('Express app not initialised yet')
+  return _app
+}
+
+function setHttpServer(server) { _httpServer = server }
+function getHttpServer() {
+  if (!_httpServer) throw new Error('HTTP server not initialised yet')
+  return _httpServer
+}
+
+module.exports = { setApp, getApp, setHttpServer, getHttpServer }

package/server/utils/session-watcher.js

@@ -1,29 +1,12 @@
 'use strict'
 
 const { veilGet } = require('./veil-client.js')
-const { getIO } = require('./socket-io.js')
 
 // Map<sessionId, number> — message count baseline (messages already seen by Studio)
-// undefined = not initialized → first syncSession will set baseline without emitting
 const _sessionState = new Map()
 
-// Prevent concurrent syncs for the same session
-const _syncing = new Set()
-
 // ─── Public API ──────────────────────────────────────────────────────────────
 
-async function syncSession(sessionId) {
-  if (_syncing.has(sessionId)) return
-  _syncing.add(sessionId)
-  try {
-    await _doSync(sessionId)
-  } catch (err) {
-    console.warn(`[session-sync] syncSession ${sessionId} failed: ${err.message}`)
-  } finally {
-    _syncing.delete(sessionId)
-  }
-}
-
 async function touchSession(sessionId) {
   // Refresh baseline without emitting — call after chat:send completes
   // so the Studio-sent messages are not re-emitted on the next external sync
@@ -36,7 +19,7 @@ async function touchSession(sessionId) {
 
 async function initSessionStates() {
   // Pre-populate message-count baselines for all active sessions so that
-  // the first syncSession call only emits truly NEW messages
+  // the WebSocket bridge only emits truly NEW messages
   try {
     const res = await veilGet('/sessions')
     const sessions = Array.isArray(res) ? res : (res.sessions ?? [])
@@ -61,48 +44,4 @@ async function initSessionStates() {
   }
 }
 
-// ─── Internal ────────────────────────────────────────────────────────────────
-
-async function _doSync(sessionId) {
-  const res = await veilGet(`/sessions/${encodeURIComponent(sessionId)}/messages`)
-  const messages = Array.isArray(res) ? res : (res.messages ?? [])
-
-  const baseline = _sessionState.get(sessionId)
-
-  if (baseline === undefined) {
-    // First contact with this session — set baseline without emitting historical messages
-    _sessionState.set(sessionId, messages.length)
-    return
-  }
-
-  const newMessages = messages.slice(baseline)
-  _sessionState.set(sessionId, messages.length)
-
-  if (newMessages.length === 0) return
-
-  const io = getIO()
-
-  for (const msg of newMessages) {
-    if (msg.role === 'user') {
-      const content = typeof msg.content === 'string'
-        ? msg.content
-        : (msg.content?.[0]?.text ?? '')
-      io.to('board').emit('chat:user-message', {
-        sessionId,
-        agentName: msg.agentName || '',
-        message: content,
-      })
-    } else if (msg.role === 'assistant') {
-      io.to('board').emit('chat:stream', {
-        sessionId,
-        eventType: 'message',
-        data: msg,
-      })
-    }
-  }
-
-  // Signal end of streaming after the batch
-  io.to('board').emit('chat:done', { sessionId, message: null, tokenUsage: null })
-}
-
-module.exports = { syncSession, touchSession, initSessionStates }
+module.exports = { touchSession, initSessionStates }

package/server/utils/terminal-manager.js

@@ -0,0 +1,212 @@
+'use strict'
+
+const pty     = require('node-pty')
+const { getIO } = require('./socket-io.js')
+
+const MAX_BUFFER_BYTES = 2 * 1024 * 1024  // 2 MB
+
+// terminalId → TerminalSession
+const sessions = new Map()
+// socketId → Set<terminalId>  (reverse index for fast disconnect cleanup)
+const socketToTerminals = new Map()
+
+// ── Public API ───────────────────────────────────────────────────────────────
+
+/**
+ * Spawn (or respawn) a PTY for the given terminalId.
+ * Safe to call on an already-exited session — clears the buffer and creates a fresh PTY.
+ * Will log a warning and do nothing if called for a still-live session.
+ */
+function createPTY(terminalId, { cols = 80, rows = 24, cwd, shell } = {}) {
+  const existing = sessions.get(terminalId)
+
+  if (existing && existing.pty && !existing.exited) {
+    console.warn(`[terminal-manager] createPTY called for live session "${terminalId}" — ignoring`)
+    return
+  }
+
+  // Create (or reset) session — preserve subscriber list on respawn so existing viewers reconnect
+  const resolvedShell = shell || process.env.SHELL || '/bin/bash'
+  const resolvedCwd   = cwd   || process.cwd()
+
+  const session = {
+    pty:          null,
+    bufferChunks: [],
+    bufferSize:   0,
+    subscribers:  existing ? existing.subscribers : new Set(),
+    exited:       false,
+    exitCode:     0,
+    cwd:          resolvedCwd,
+    shell:        resolvedShell,
+  }
+  sessions.set(terminalId, session)
+
+  let ptyProcess
+  try {
+    ptyProcess = pty.spawn(resolvedShell, [], {
+      name: 'xterm-color',
+      cols,
+      rows,
+      cwd:  resolvedCwd,
+      env:  { ...process.env, TERM: 'xterm-color', COLORTERM: 'truecolor' },
+    })
+  } catch (err) {
+    console.error(`[terminal-manager] Failed to spawn PTY for "${terminalId}":`, err.message)
+    sessions.delete(terminalId)
+    const io = getIO()
+    for (const socketId of session.subscribers) {
+      io.to(socketId).emit('terminal:exit', { terminalId, code: -1 })
+    }
+    return
+  }
+
+  session.pty = ptyProcess
+
+  ptyProcess.on('data', (data) => {
+    // Append raw output to replay buffer (ANSI sequences included — xterm re-parses on write)
+    session.bufferChunks.push(data)
+    session.bufferSize += data.length
+    // Trim oldest chunks when over cap
+    while (session.bufferSize > MAX_BUFFER_BYTES && session.bufferChunks.length > 1) {
+      session.bufferSize -= session.bufferChunks[0].length
+      session.bufferChunks.shift()
+    }
+    // Broadcast to all subscribers
+    const io = getIO()
+    for (const socketId of session.subscribers) {
+      io.to(socketId).emit('terminal:data', { terminalId, data })
+    }
+  })
+
+  ptyProcess.on('exit', (code) => {
+    // Guard: session may have already been removed by destroyPTY()
+    if (!sessions.has(terminalId)) return
+    session.pty      = null
+    session.exited   = true
+    session.exitCode = code ?? 0
+    const io = getIO()
+    for (const socketId of session.subscribers) {
+      io.to(socketId).emit('terminal:exit', { terminalId, code: code ?? 0 })
+    }
+  })
+}
+
+/**
+ * Kill the PTY and remove the session entirely.
+ * Called by: element onDestroy(), terminal:destroy socket event.
+ */
+function destroyPTY(terminalId) {
+  const session = sessions.get(terminalId)
+  if (!session) return
+  if (session.pty) {
+    try { session.pty.kill() } catch (_) {}
+    session.pty = null
+  }
+  // Clean up reverse-map entries for all subscribers
+  for (const socketId of session.subscribers) {
+    const set = socketToTerminals.get(socketId)
+    if (set) set.delete(terminalId)
+  }
+  sessions.delete(terminalId)
+}
+
+/**
+ * Register a socket as a viewer of a terminal session.
+ * Creates a stub session entry if one doesn't exist yet.
+ * Returns true if this is a NEW subscription (socket wasn't already subscribed).
+ */
+function subscribe(terminalId, socketId) {
+  if (!sessions.has(terminalId)) {
+    sessions.set(terminalId, {
+      pty: null, bufferChunks: [], bufferSize: 0,
+      subscribers: new Set(), exited: false, exitCode: 0,
+    })
+  }
+  const session = sessions.get(terminalId)
+  const isNew   = !session.subscribers.has(socketId)
+  session.subscribers.add(socketId)
+
+  if (!socketToTerminals.has(socketId)) socketToTerminals.set(socketId, new Set())
+  socketToTerminals.get(socketId).add(terminalId)
+
+  return isNew
+}
+
+/**
+ * Remove a socket from all terminal subscriptions.
+ * Called on socket disconnect — does NOT kill any PTYs.
+ */
+function unsubscribeSocket(socketId) {
+  const terminals = socketToTerminals.get(socketId)
+  if (!terminals) return
+  for (const terminalId of terminals) {
+    const session = sessions.get(terminalId)
+    if (session) session.subscribers.delete(socketId)
+  }
+  socketToTerminals.delete(socketId)
+}
+
+function write(terminalId, data) {
+  const session = sessions.get(terminalId)
+  if (!session || !session.pty) return
+  session.pty.write(data)
+}
+
+function resize(terminalId, cols, rows) {
+  const session = sessions.get(terminalId)
+  if (!session || !session.pty) return
+  try { session.pty.resize(cols, rows) } catch (_) {}
+}
+
+function getReplayBuffer(terminalId) {
+  const session = sessions.get(terminalId)
+  if (!session || session.bufferChunks.length === 0) return ''
+  return session.bufferChunks.join('')
+}
+
+function hasPTY(terminalId) {
+  const s = sessions.get(terminalId)
+  return !!(s && s.pty)
+}
+
+function isExited(terminalId) {
+  const s = sessions.get(terminalId)
+  return !!(s && s.exited)
+}
+
+function getPID(terminalId) {
+  const s = sessions.get(terminalId)
+  return s?.pty?.pid ?? null
+}
+
+/**
+ * Returns metadata for all currently-tracked sessions (including exited ones).
+ * Used by clients to rediscover running terminals after a page reload.
+ */
+function listSessions() {
+  const result = []
+  for (const [terminalId, session] of sessions) {
+    result.push({
+      terminalId,
+      pid:    session.pty?.pid ?? null,
+      cwd:    session.cwd    ?? null,
+      shell:  session.shell  ?? null,
+      exited: session.exited,
+    })
+  }
+  return result
+}
+
+module.exports = {
+  createPTY,
+  destroyPTY,
+  subscribe,
+  unsubscribeSocket,
+  write,
+  resize,
+  getReplayBuffer,
+  hasPTY,
+  isExited,
+  getPID,
+  listSessions,
+}