muuuuse 1.3.2 → 1.4.0

package/src/runtime.js

@@ -2,151 +2,103 @@ const fs = require("node:fs");
 const path = require("node:path");
 const pty = require("node-pty");
 
-const {
-  detectAgentTypeFromCommand,
-  expandPresetCommand,
-  readClaudeAnswers,
-  readCodexAnswers,
-  readGeminiAnswers,
-  selectClaudeSessionFile,
-  selectCodexSessionFile,
-  selectGeminiSessionFile,
-} = require("./agents");
 const {
   BRAND,
   POLL_MS,
   appendJsonl,
   createId,
+  ensureDir,
   getDefaultSessionName,
   getFileSize,
   getSeatPaths,
   getStateRoot,
   hashText,
   isPidAlive,
+  listSessionNames,
   readAppendedText,
   readJson,
-  resetDir,
   sanitizeRelayText,
   sleep,
   writeJson,
 } = require("./util");
 
-const GENERIC_IDLE_MS = 900;
+const BELL = "\u0007";
+const CTRL_C = "\u0003";
 
-function resolveSessionName(sessionOverride, currentPath = process.cwd()) {
-  return sessionOverride || getDefaultSessionName(currentPath);
+function resolveShell() {
+  const shell = String(process.env.SHELL || "").trim();
+  return shell || "/bin/bash";
 }
 
-function resolveProgramTokens(commandTokens, usePresets = true) {
-  const resolved = expandPresetCommand(commandTokens, usePresets);
-  if (resolved.length === 0) {
-    throw new Error("Seat commands now require a program. Example: `muuuuse 1 codex`.");
+function resolveShellArgs(shellPath) {
+  const base = path.basename(shellPath);
+  if (base === "bash" || base === "zsh") {
+    return ["-l"];
   }
-  return resolved;
+  return [];
 }
 
-function formatCommand(commandTokens) {
-  return commandTokens
-    .map((token) => {
-      if (/^[a-zA-Z0-9._/@:=+-]+$/.test(token)) {
-        return token;
-      }
-      return JSON.stringify(token);
-    })
-    .join(" ");
-}
-
-function previewText(text, maxLength = 88) {
-  const compact = sanitizeRelayText(text).replace(/\s+/g, " ");
-  if (compact.length <= maxLength) {
-    return compact;
+function resolveChildTerm() {
+  const inherited = String(process.env.TERM || "").trim();
+  if (inherited && inherited.toLowerCase() !== "dumb") {
+    return inherited;
   }
-  return `${compact.slice(0, maxLength - 3)}...`;
+  return "xterm-256color";
 }
 
-function parseAnswerEntries(text) {
-  return String(text || "")
-    .split("\n")
-    .map((line) => line.trim())
-    .filter((line) => line.length > 0)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch (error) {
-        return null;
-      }
-    })
-    .filter((entry) => entry && entry.type === "answer" && typeof entry.text === "string");
+function resolveSessionName(currentPath = process.cwd()) {
+  return getDefaultSessionName(currentPath);
 }
 
-function resolveSessionFile(agentType, currentPath, processStartedAtMs, options = {}) {
-  if (agentType === "codex") {
-    return selectCodexSessionFile(currentPath, processStartedAtMs, options);
-  }
-  if (agentType === "claude") {
-    return selectClaudeSessionFile(currentPath, processStartedAtMs);
-  }
-  if (agentType === "gemini") {
-    return selectGeminiSessionFile(currentPath, processStartedAtMs);
-  }
-  return null;
-}
-
-class GenericAnswerTracker {
+class BellRelayTracker {
   constructor() {
     this.active = false;
     this.buffer = "";
     this.lastInputText = "";
-    this.lastOutputAt = 0;
     this.lastFingerprint = null;
   }
 
   noteTurnStart(inputText = "") {
     this.active = true;
     this.buffer = "";
-    this.lastInputText = sanitizeRelayText(inputText);
-    this.lastOutputAt = 0;
+    this.lastInputText = sanitizeRelayText(inputText, 12000);
   }
 
   append(data) {
-    if (!this.active) {
-      return;
+    const text = String(data || "");
+    if (!text || !this.active) {
+      return [];
     }
 
-    this.buffer += String(data || "");
-    this.lastOutputAt = Date.now();
-
-    if (this.buffer.length > 24000) {
-      this.buffer = this.buffer.slice(-24000);
-    }
-  }
-
-  consumeReady() {
-    if (!this.active || !this.lastOutputAt) {
-      return null;
-    }
-
-    if (Date.now() - this.lastOutputAt < GENERIC_IDLE_MS) {
-      return null;
-    }
-
-    const text = extractGenericAnswer(this.buffer, this.lastInputText);
-    if (!text) {
-      return null;
-    }
+    const answers = [];
+    for (const char of text) {
+      if (char === BELL) {
+        const answer = extractFinalBlock(this.buffer, this.lastInputText);
+        this.buffer = "";
+        this.active = false;
+        if (!answer) {
+          continue;
+        }
+        const fingerprint = hashText(`${this.lastInputText}\n${answer}`);
+        if (fingerprint === this.lastFingerprint) {
+          continue;
+        }
+        this.lastFingerprint = fingerprint;
+        answers.push(answer);
+        continue;
+      }
 
-    const fingerprint = hashText(`${this.lastInputText}\n${text}`);
-    if (fingerprint === this.lastFingerprint) {
-      return null;
+      this.buffer += char;
+      if (this.buffer.length > 24000) {
+        this.buffer = this.buffer.slice(-24000);
+      }
     }
 
-    this.lastFingerprint = fingerprint;
-    this.active = false;
-    return text;
+    return answers;
   }
 }
 
-function extractGenericAnswer(rawText, lastInputText) {
+function extractFinalBlock(rawText, lastInputText) {
   let candidate = sanitizeRelayText(rawText, 12000);
   if (!candidate) {
     return null;
@@ -161,15 +113,10 @@ function extractGenericAnswer(rawText, lastInputText) {
     }
   }
 
-  const markerAnswer = extractMarkedAnswer(candidate);
-  if (markerAnswer) {
-    return markerAnswer;
-  }
-
   const blocks = candidate
     .split(/\n{2,}/)
     .map((block) => block.trim())
-    .filter((block) => block.length > 0);
+    .filter(Boolean);
 
   if (blocks.length === 0) {
     return null;
@@ -178,51 +125,42 @@ function extractGenericAnswer(rawText, lastInputText) {
   return sanitizeRelayText(blocks[blocks.length - 1]);
 }
 
-function extractMarkedAnswer(content) {
-  const lines = String(content || "").split("\n");
-  const answerIndex = lines.findIndex((line) => line.trim().startsWith("(answer)"));
-  if (answerIndex === -1) {
-    return null;
-  }
-
-  const answerLines = lines.slice(answerIndex);
-  answerLines[0] = answerLines[0].trim().replace(/^\(answer\)\s*/, "");
-  return sanitizeRelayText(answerLines.join("\n"));
+function parseAnswerEntries(text) {
+  return String(text || "")
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter((entry) => entry && entry.type === "answer" && typeof entry.text === "string");
 }
 
-class SeatProcess {
+class ArmedSeat {
   constructor(options) {
     this.seatId = options.seatId;
     this.partnerSeatId = options.seatId === 1 ? 2 : 1;
-    this.sessionName = options.sessionName;
     this.cwd = options.cwd;
-    this.commandTokens = [...options.commandTokens];
-    this.agentType = detectAgentTypeFromCommand(this.commandTokens);
-    this.maxRelays = options.maxRelays;
-
+    this.sessionName = resolveSessionName(this.cwd);
     this.paths = getSeatPaths(this.sessionName, this.seatId);
     this.partnerPaths = getSeatPaths(this.sessionName, this.partnerSeatId);
     this.partnerOffset = getFileSize(this.partnerPaths.eventsPath);
 
     this.child = null;
     this.childPid = null;
+    this.childPgid = null;
     this.childExit = null;
-    this.startedAtMs = Date.now();
+    this.startedAt = new Date().toISOString();
     this.relayCount = 0;
-    this.linked = false;
+    this.pendingInput = "";
     this.stopped = false;
     this.stdinCleanup = null;
     this.resizeCleanup = null;
-    this.childToken = createId(16);
-    this.processStartedAtMs = null;
-
-    this.sessionState = {
-      file: null,
-      offset: 0,
-      lastMessageId: null,
-    };
-
-    this.genericTracker = new GenericAnswerTracker();
+    this.tracker = new BellRelayTracker();
   }
 
   log(message) {
@@ -232,15 +170,13 @@ class SeatProcess {
   writeMeta(extra = {}) {
     writeJson(this.paths.metaPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
-      childToken: this.childToken,
-      agentType: this.agentType,
-      command: this.commandTokens,
-      commandLine: formatCommand(this.commandTokens),
-      startedAt: new Date(this.startedAtMs).toISOString(),
+      command: [resolveShell(), ...resolveShellArgs(resolveShell())],
+      startedAt: this.startedAt,
       ...extra,
     });
   }
@@ -248,26 +184,54 @@ class SeatProcess {
   writeStatus(extra = {}) {
     writeJson(this.paths.statusPath, {
       seatId: this.seatId,
+      partnerSeatId: this.partnerSeatId,
       sessionName: this.sessionName,
       cwd: this.cwd,
       pid: process.pid,
       childPid: this.childPid,
-      childToken: this.childToken,
-      agentType: this.agentType,
-      command: this.commandTokens,
       relayCount: this.relayCount,
       updatedAt: new Date().toISOString(),
       ...extra,
     });
   }
 
-  installSignalHandlers() {
-    const stop = () => {
+  launchShell() {
+    ensureDir(this.paths.dir);
+    fs.rmSync(this.paths.pipePath, { force: true });
+
+    const shell = resolveShell();
+    const shellArgs = resolveShellArgs(shell);
+    this.child = pty.spawn(shell, shellArgs, {
+      cols: process.stdout.columns || 120,
+      rows: process.stdout.rows || 36,
+      cwd: this.cwd,
+      env: {
+        ...process.env,
+        TERM: resolveChildTerm(),
+        MUUUUSE_SEAT: String(this.seatId),
+        MUUUUSE_SESSION: this.sessionName,
+      },
+      name: resolveChildTerm(),
+    });
+
+    this.childPid = this.child.pid;
+    this.childPgid = this.child.pid;
+    this.writeMeta();
+    this.writeStatus({ state: "running" });
+
+    this.child.onData((data) => {
+      fs.appendFileSync(this.paths.pipePath, data);
+      process.stdout.write(data);
+      const answers = this.tracker.append(data);
+      for (const answer of answers) {
+        this.emitAnswer(answer);
+      }
+    });
+
+    this.child.onExit(({ exitCode, signal }) => {
+      this.childExit = { exitCode, signal: signal || null };
       this.stopped = true;
-    };
-    process.once("SIGINT", stop);
-    process.once("SIGHUP", stop);
-    process.once("SIGTERM", stop);
+    });
   }
 
   installStdinProxy() {
@@ -278,10 +242,9 @@ class SeatProcess {
 
       const text = chunk.toString("utf8");
       this.child.write(text);
-      if (this.shouldUseGenericCapture() && /[\r\n]/.test(text)) {
-        this.genericTracker.noteTurnStart("");
-      }
+      this.trackInput(text);
     };
+
     const handleEnd = () => {
       this.stopped = true;
     };
@@ -315,9 +278,9 @@ class SeatProcess {
       }
 
       try {
-        this.child.resize(process.stdout.columns || 80, process.stdout.rows || 24);
-      } catch (error) {
-        // Ignore resize failures while the child is exiting.
+        this.child.resize(process.stdout.columns || 120, process.stdout.rows || 36);
+      } catch {
+        // Ignore resize races while the child is exiting.
       }
     };
 
@@ -327,63 +290,40 @@ class SeatProcess {
     };
   }
 
-  launchChild() {
-    resetDir(this.paths.dir);
-
-    const [file, ...args] = this.commandTokens;
-    this.child = pty.spawn(file, args, {
-      cols: process.stdout.columns || 80,
-      cwd: this.cwd,
-      env: {
-        ...process.env,
-        MUUUUSE_CHILD_TOKEN: this.childToken,
-        MUUUUSE_SEAT: String(this.seatId),
-        MUUUUSE_SESSION: this.sessionName,
-      },
-      name: process.env.TERM || "xterm-256color",
-      rows: process.stdout.rows || 24,
-    });
+  installStopSignals() {
+    const requestStop = () => {
+      this.stopped = true;
+    };
 
-    this.childPid = this.child.pid;
-    this.processStartedAtMs = Date.now();
-    this.writeMeta();
-    this.writeStatus({
-      partnerSeatId: this.partnerSeatId,
-      state: "running",
-    });
+    process.on("SIGTERM", requestStop);
+    process.on("SIGHUP", requestStop);
+  }
 
-    this.child.onData((data) => {
-      process.stdout.write(data);
-      if (this.shouldUseGenericCapture()) {
-        this.genericTracker.append(data);
+  trackInput(text) {
+    for (const char of String(text || "")) {
+      if (char === CTRL_C) {
+        this.pendingInput = "";
+        this.tracker.noteTurnStart("");
+        continue;
       }
-    });
-
-    this.child.onExit(({ exitCode, signal }) => {
-      this.childExit = {
-        exitCode,
-        signal: signal || null,
-      };
-      this.stopped = true;
-    });
-  }
 
-  partnerIsLive() {
-    const partnerStatus = readJson(this.partnerPaths.statusPath, null);
-    return Boolean(partnerStatus?.pid && isPidAlive(partnerStatus.pid));
-  }
+      if (char === "\r" || char === "\n") {
+        const submitted = sanitizeRelayText(this.pendingInput, 12000);
+        this.pendingInput = "";
+        this.tracker.noteTurnStart(submitted);
+        continue;
+      }
 
-  maybeMarkLinked() {
-    if (this.linked || !this.partnerIsLive()) {
-      return;
+      this.pendingInput += char;
+      if (this.pendingInput.length > 4000) {
+        this.pendingInput = this.pendingInput.slice(-4000);
+      }
     }
-
-    this.linked = true;
-    this.log(`${BRAND} seat ${this.seatId} linked with seat ${this.partnerSeatId} in session ${this.sessionName}.`);
   }
 
-  shouldUseGenericCapture() {
-    return !this.agentType;
+  partnerIsLive() {
+    const partner = readJson(this.partnerPaths.statusPath, null);
+    return Boolean(partner?.pid && isPidAlive(partner.pid));
   }
 
   pullPartnerEvents() {
@@ -395,23 +335,12 @@ class SeatProcess {
 
     const entries = parseAnswerEntries(text);
     for (const entry of entries) {
-      if (!this.child) {
-        continue;
-      }
-      if (Number.isFinite(this.maxRelays) && this.relayCount >= this.maxRelays) {
-        this.log(`${BRAND} seat ${this.seatId} hit the relay cap (${this.maxRelays}).`);
-        continue;
-      }
-
       const payload = sanitizeRelayText(entry.text);
-      if (!payload) {
+      if (!payload || !this.child) {
         continue;
       }
 
-      if (this.shouldUseGenericCapture()) {
-        this.genericTracker.noteTurnStart(payload);
-      }
-
+      this.tracker.noteTurnStart(payload);
       this.child.write(payload.replace(/\n/g, "\r"));
       this.child.write("\r");
       this.relayCount += 1;
@@ -419,125 +348,40 @@ class SeatProcess {
     }
   }
 
-  resolveStructuredLog() {
-    if (!this.agentType || this.sessionState.file) {
-      return;
-    }
-
-    const sessionFile = resolveSessionFile(this.agentType, this.cwd, this.processStartedAtMs, {
-      snapshotEnv: this.agentType === "codex"
-        ? {
-          MUUUUSE_CHILD_TOKEN: this.childToken,
-          MUUUUSE_SEAT: String(this.seatId),
-          MUUUUSE_SESSION: this.sessionName,
-        }
-        : null,
-    });
-    if (!sessionFile) {
-      return;
-    }
-
-    this.sessionState.file = sessionFile;
-    if (this.agentType === "gemini") {
-      const baseline = readGeminiAnswers(sessionFile, null);
-      this.sessionState.lastMessageId = baseline.lastMessageId;
-      this.sessionState.offset = baseline.fileSize;
-    } else {
-      this.sessionState.offset = getFileSize(sessionFile);
-    }
-  }
-
-  collectStructuredAnswers() {
-    this.resolveStructuredLog();
-    if (!this.sessionState.file || !this.agentType) {
-      return;
-    }
-
-    const answers = [];
-    if (this.agentType === "codex") {
-      const result = readCodexAnswers(this.sessionState.file, this.sessionState.offset);
-      this.sessionState.offset = result.nextOffset;
-      answers.push(...result.answers);
-    } else if (this.agentType === "claude") {
-      const result = readClaudeAnswers(this.sessionState.file, this.sessionState.offset);
-      this.sessionState.offset = result.nextOffset;
-      answers.push(...result.answers);
-    } else if (this.agentType === "gemini") {
-      const result = readGeminiAnswers(this.sessionState.file, this.sessionState.lastMessageId);
-      this.sessionState.lastMessageId = result.lastMessageId;
-      this.sessionState.offset = result.fileSize;
-      answers.push(...result.answers);
-    }
-
-    for (const answer of answers) {
-      this.emitAnswer({
-        createdAt: answer.timestamp,
-        id: answer.id,
-        origin: this.agentType,
-        text: answer.text,
-      });
-    }
-  }
-
-  collectGenericAnswers() {
-    if (!this.shouldUseGenericCapture()) {
-      return;
-    }
-
-    const text = this.genericTracker.consumeReady();
-    if (!text) {
-      return;
-    }
-
-    this.emitAnswer({
-      createdAt: new Date().toISOString(),
-      id: createId(12),
-      origin: "generic",
-      text,
-    });
-  }
-
-  emitAnswer(entry) {
-    const text = sanitizeRelayText(entry.text);
-    if (!text) {
+  emitAnswer(text) {
+    const payload = sanitizeRelayText(text);
+    if (!payload) {
       return;
     }
 
     appendJsonl(this.paths.eventsPath, {
-      id: entry.id || createId(12),
+      id: createId(12),
       type: "answer",
       seatId: this.seatId,
-      origin: entry.origin || "unknown",
-      text,
-      createdAt: entry.createdAt || new Date().toISOString(),
+      text: payload,
+      createdAt: new Date().toISOString(),
     });
 
-    this.log(`[${this.seatId}] ${previewText(text)}`);
+    this.log(`[${this.seatId}] ${previewText(payload)}`);
   }
 
   async tick() {
-    this.maybeMarkLinked();
     this.pullPartnerEvents();
-    this.collectStructuredAnswers();
-    this.collectGenericAnswers();
-
     this.writeStatus({
-      partnerSeatId: this.partnerSeatId,
       partnerLive: this.partnerIsLive(),
       state: this.childExit ? "exited" : "running",
-      structuredLog: this.sessionState.file,
     });
   }
 
   async run() {
-    this.installSignalHandlers();
-    this.launchChild();
+    this.installStopSignals();
+    this.launchShell();
     this.installStdinProxy();
     this.installResizeHandler();
 
-    this.log(`${BRAND} seat ${this.seatId} started in session ${this.sessionName}.`);
-    this.log(`Command: ${formatCommand(this.commandTokens)}`);
-    this.log(`Stop everything from another terminal with: muuuuse stop`);
+    this.log(`${BRAND} seat ${this.seatId} armed for ${this.sessionName}.`);
+    this.log("Use this shell normally. When a program rings the terminal bell, the final block relays to the partner seat.");
+    this.log("Run `muuuuse stop` from any other shell to stop the loop.");
 
     try {
       while (!this.stopped) {
@@ -561,13 +405,10 @@ class SeatProcess {
       this.resizeCleanup = null;
     }
 
-    if (this.child && !this.childExit) {
-      try {
-        this.child.kill("SIGTERM");
-      } catch (error) {
-        // Ignore races during shutdown.
-      }
-    }
+    stopTrackedSeat({
+      childPid: this.childPid,
+      wrapperPid: process.pid,
+    });
 
     this.writeMeta({
       childPid: this.childPid,
@@ -575,135 +416,83 @@ class SeatProcess {
     });
     this.writeStatus({
       childPid: this.childPid,
-      exitCode: this.childExit?.exitCode ?? null,
       exitedAt: new Date().toISOString(),
-      partnerSeatId: this.partnerSeatId,
       state: "exited",
     });
   }
 }
 
-function stopSession(sessionName) {
-  const results = [];
-
-  for (const seatId of [1, 2]) {
-    const paths = getSeatPaths(sessionName, seatId);
-    const status = readJson(paths.statusPath, null);
-    const meta = readJson(paths.metaPath, null);
-    const wrapperPid = status?.pid || meta?.pid || null;
-    const childPid = status?.childPid || meta?.childPid || null;
-
-    let wrapperStopped = false;
-    let childStopped = false;
-
-    if (wrapperPid && isPidAlive(wrapperPid)) {
-      try {
-        process.kill(wrapperPid, "SIGTERM");
-        wrapperStopped = true;
-      } catch (error) {
-        wrapperStopped = false;
-      }
-    }
-
-    if (childPid && isPidAlive(childPid)) {
-      try {
-        process.kill(childPid, "SIGTERM");
-        childStopped = true;
-      } catch (error) {
-        childStopped = false;
-      }
-    }
-
-    results.push({
-      seatId,
-      childPid,
-      childStopped,
-      wrapperPid,
-      wrapperStopped,
-    });
+function previewText(text, maxLength = 88) {
+  const compact = sanitizeRelayText(text).replace(/\s+/g, " ");
+  if (compact.length <= maxLength) {
+    return compact;
   }
-
-  return {
-    sessionName,
-    seats: results,
-  };
+  return `${compact.slice(0, maxLength - 3)}...`;
 }
 
-function listSessionNames() {
-  const sessionsRoot = path.join(getStateRoot(), "sessions");
+function signalPid(pid, signal) {
+  if (!Number.isInteger(pid) || pid <= 0 || !isPidAlive(pid)) {
+    return false;
+  }
   try {
-    return fs.readdirSync(sessionsRoot, { withFileTypes: true })
-      .filter((entry) => entry.isDirectory())
-      .map((entry) => entry.name)
-      .sort();
-  } catch (error) {
-    return [];
+    process.kill(pid, signal);
+    return true;
+  } catch {
+    return false;
   }
 }
 
-async function stopSessions(sessionName = null) {
-  const sessionNames = sessionName ? [sessionName] : listSessionNames();
-  const sessionResults = sessionNames.map((name) => stopSession(name));
-
-  await sleep(200);
+function stopTrackedSeat({ wrapperPid = null, childPid = null }) {
+  const childStopped = signalPid(childPid, "SIGTERM");
+  const wrapperStopped = wrapperPid === process.pid ? false : signalPid(wrapperPid, "SIGTERM");
+  return { childStopped, wrapperStopped };
+}
 
-  for (const sessionResult of sessionResults) {
-    for (const seat of sessionResult.seats) {
-      if (seat.wrapperPid && isPidAlive(seat.wrapperPid)) {
-        try {
-          process.kill(seat.wrapperPid, "SIGKILL");
-          seat.wrapperForced = true;
-        } catch (error) {
-          seat.wrapperForced = false;
-        }
-      } else {
-        seat.wrapperForced = false;
-      }
+function stopSession(sessionName) {
+  const seats = [1, 2]
+    .map((seatId) => {
+      const paths = getSeatPaths(sessionName, seatId);
+      const status = readJson(paths.statusPath, null);
+      const wrapperPid = status?.pid || null;
+      const childPid = status?.childPid || null;
+      const wrapperLive = isPidAlive(wrapperPid);
+      const childLive = isPidAlive(childPid);
 
-      if (seat.childPid && isPidAlive(seat.childPid)) {
-        try {
-          process.kill(seat.childPid, "SIGKILL");
-          seat.childForced = true;
-        } catch (error) {
-          seat.childForced = false;
-        }
-      } else {
-        seat.childForced = false;
+      if (!wrapperLive && !childLive) {
+        return null;
       }
-    }
-  }
 
-  return {
-    sessionName,
-    sessions: sessionResults,
-  };
-}
+      const result = stopTrackedSeat({ wrapperPid, childPid });
+      writeJson(paths.statusPath, {
+        ...(status || {}),
+        state: "stopping",
+        updatedAt: new Date().toISOString(),
+      });
 
-function readSessionStatus(sessionName) {
-  return {
-    sessionName,
-    seats: [1, 2].map((seatId) => {
-      const paths = getSeatPaths(sessionName, seatId);
-      const status = readJson(paths.statusPath, null);
       return {
         seatId,
-        status,
+        wrapperStopped: result.wrapperStopped,
+        childStopped: result.childStopped,
       };
-    }),
-  };
+    })
+    .filter(Boolean);
+
+  if (seats.length === 0) {
+    return null;
+  }
+
+  return { sessionName, seats };
 }
 
-function readAllSessionStatuses() {
-  return listSessionNames().map((sessionName) => readSessionStatus(sessionName));
+function stopAllSessions() {
+  const sessions = listSessionNames()
+    .map((sessionName) => stopSession(sessionName))
+    .filter(Boolean);
+  return { sessions };
 }
 
 module.exports = {
-  SeatProcess,
-  formatCommand,
-  readAllSessionStatuses,
-  readSessionStatus,
-  resolveProgramTokens,
+  ArmedSeat,
   resolveSessionName,
-  stopSession,
-  stopSessions,
+  stopAllSessions,
 };