muuuuse 1.3.2 → 1.4.0

package/README.md

@@ -1,105 +1,85 @@
 # 🔌Muuuuse
 
-`muuuuse` installs one CLI:
+`🔌Muuuuse` is a dead-simple terminal relay.
 
-- `muuuuse`
+It does one thing:
+- arm two raw terminals
+- watch for the final BEL-marked message from whatever program is running inside them
+- inject that final message into the other armed terminal
+- keep bouncing forever until you stop it
 
-The public brand stays `🔌Muuuuse`. The terminal command stays `muuuuse`.
-
-## What It Is Now
-
-`🔌Muuuuse` no longer expects you to arm a terminal first and launch something later.
-
-The main flow is:
+There are only three commands:
 
 ```bash
-muuuuse 1 <program...>
-muuuuse 2 <program...>
+muuuuse 1
+muuuuse 2
 muuuuse stop
 ```
 
-Seat `1` and seat `2` each launch and own a real local program under a PTY wrapper. Once both seats are alive in the same lane, they automatically bounce final blocks between each other by typing the partner answer plus `Enter` into the wrapped program.
+No tmux.
+No program arguments.
+No status command.
+No doctor command.
+No preset logic.
 
-`muuuuse stop` is the real cleanup command. With no flags it force-stops every tracked lane. Use `--session <name>` if you only want one explicit lane.
+## Flow
 
-## Install
+Shell 1:
 
 ```bash
-npm install -g muuuuse
+muuuuse 1
 ```
 
-## Fastest AI Flow
-
-Terminal 1:
+Shell 2:
 
 ```bash
-muuuuse 1 codex
+muuuuse 2
 ```
 
-Terminal 2:
+Now both shells are armed. Use them normally.
 
-```bash
-muuuuse 2 gemini
-```
-
-Terminal 3:
+If you want Codex in one and Gemini in the other, start them inside the armed shells:
 
 ```bash
-muuuuse stop
+codex
 ```
 
-Known presets expand to recommended flags automatically:
-
-- `codex`
-- `claude`
-- `gemini`
-
-So `muuuuse 1 codex` launches the fuller Codex command, not just bare `codex`.
-
-## Generic Program Flow
-
-This is not AI-only. Any local program can be wrapped directly.
-
-Example:
-
 ```bash
-muuuuse 1 bash -lc 'while read line; do printf "left: %s\n\n" "$line"; done'
-muuuuse 2 bash -lc 'while read line; do printf "right: %s\n\n" "$line"; done'
+gemini
 ```
 
-Type into one seat and the other seat will receive the relayed block.
-
-For Codex, Claude, and Gemini, `🔌Muuuuse` waits for their structured final-answer logs instead of relaying transient screen chatter. For anything else, it first looks for an explicit `(answer)` block and otherwise falls back to the last stable output block after a turn goes idle.
-
-## Sessions
+Or run any other program. `🔌Muuuuse` is program-agnostic.
 
-Seats auto-pair by current working directory by default.
+When the running program rings the terminal bell, `🔌Muuuuse` takes the final output block for that turn and injects it into the partner seat.
 
-If you want an explicit lane name, use:
+Stop the whole loop from any other shell:
 
 ```bash
-muuuuse 1 --session demo codex
-muuuuse 2 --session demo gemini
-muuuuse stop --session demo
+muuuuse stop
 ```
 
-You can also inspect the lane:
+## Install
 
 ```bash
-muuuuse status
+npm install -g muuuuse
 ```
 
-## Doctor
+## What Counts As A Relay
 
-```bash
-muuuuse doctor
-```
+`🔌Muuuuse` watches the armed terminal output for BEL (`\u0007`).
+
+That BEL marks the end of a turn.
 
-This checks the local runtime plus common agent binaries if you use them.
+When it sees BEL, it:
+1. grabs the final output block since the last submitted input
+2. cleans the block
+3. appends it to the seat event log
+4. injects it into the other armed terminal followed by Enter
 
 ## Notes
 
 - local only
-- no tmux requirement for the main path
-- no remote control surface here; that belongs to `codeman`
-- best with programs that naturally produce turn-shaped output
+- seat pairing defaults by current working directory
+- state lives under `~/.muuuuse`
+- `codeman` remains the richer transport layer
+- `🔌Muuuuse` is the tiny relay protocol

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "1.3.2",
-  "description": "🔌Muuuuse wraps two local programs and bounces final blocks between them from the terminal you launched.",
+  "version": "1.4.0",
+  "description": "🔌Muuuuse arms two raw terminals and bounces BEL-marked final output between them.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"
@@ -34,7 +34,6 @@
     "relay",
     "local",
     "automation",
-    "script",
     "codex",
     "claude",
     "gemini"

package/src/cli.js

@@ -1,18 +1,5 @@
-const {
-  BRAND,
-  commandExists,
-  parseFlags,
-  readCommandVersion,
-  usage,
-} = require("./util");
-const {
-  SeatProcess,
-  readAllSessionStatuses,
-  readSessionStatus,
-  resolveProgramTokens,
-  resolveSessionName,
-  stopSessions,
-} = require("./runtime");
+const { BRAND, usage } = require("./util");
+const { ArmedSeat, stopAllSessions } = require("./runtime");
 
 async function main(argv = process.argv.slice(2)) {
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
@@ -20,154 +7,49 @@ async function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  const command = argv[0];
-
-  if (command === "doctor") {
-    runDoctor();
-    return;
-  }
+  const command = String(argv[0] || "").trim().toLowerCase();
 
   if (command === "stop") {
-    const { flags } = parseFlags(argv.slice(1));
-    const result = await stopSessions(flags.session || null);
-    if (result.sessions.length === 0) {
-      process.stdout.write(`${BRAND} no live sessions found.\n`);
-      return;
+    if (argv.length > 1) {
+      throw new Error("`muuuuse stop` takes no extra arguments.");
     }
 
-    if (flags.session) {
-      process.stdout.write(`${BRAND} stop requested for session ${flags.session}.\n`);
-    } else {
-      process.stdout.write(`${BRAND} stop requested for all sessions.\n`);
+    const result = stopAllSessions();
+    if (result.sessions.length === 0) {
+      process.stdout.write(`${BRAND} no armed seats found.\n`);
+      return;
     }
 
+    process.stdout.write(`${BRAND} stop requested.\n`);
     for (const session of result.sessions) {
       process.stdout.write(`${session.sessionName}\n`);
       for (const seat of session.seats) {
-        process.stdout.write(
-          `seat ${seat.seatId}: wrapper ${describeStopResult(seat.wrapperStopped, seat.wrapperForced)}`
-          + `, child ${describeStopResult(seat.childStopped, seat.childForced)}\n`
-        );
+        process.stdout.write(`seat ${seat.seatId}: wrapper ${describeStopResult(seat.wrapperStopped)} · child ${describeStopResult(seat.childStopped)}\n`);
       }
     }
     return;
   }
 
-  if (command === "status") {
-    const { flags } = parseFlags(argv.slice(1));
-    if (flags.session) {
-      printSessionStatus(readSessionStatus(flags.session));
-      return;
-    }
-
-    const sessions = readAllSessionStatuses();
-    if (sessions.length === 0) {
-      process.stdout.write(`${BRAND} no tracked sessions.\n`);
-      return;
-    }
-
-    for (const session of sessions) {
-      printSessionStatus(session);
+  if (command === "1" || command === "2") {
+    if (argv.length > 1) {
+      throw new Error(`\`muuuuse ${command}\` no longer takes a program. It arms this terminal raw.`);
     }
-    return;
-  }
 
-  if (command === "1" || command === "2") {
-    const { positionals, flags } = parseFlags(argv.slice(1));
-    const sessionName = resolveSessionName(flags.session, process.cwd());
-    const commandTokens = resolveProgramTokens(positionals, !flags.noPreset);
-    const seat = new SeatProcess({
-      commandTokens,
+    const seat = new ArmedSeat({
       cwd: process.cwd(),
-      maxRelays: flags.maxRelays,
       seatId: Number(command),
-      sessionName,
     });
     const code = await seat.run();
     process.exit(code);
   }
 
-  if (command === "3") {
-    const { positionals, flags } = parseFlags(argv.slice(1));
-    const action = String(positionals[0] || "status").toLowerCase();
-
-    if (action === "stop") {
-      const forwarded = ["stop", ...argv.slice(1).filter((token) => token !== "stop")];
-      await main(forwarded);
-      return;
-    }
-
-    if (action === "status") {
-      const forwarded = ["status", ...argv.slice(1).filter((token) => token !== "status")];
-      await main(forwarded);
-      return;
-    }
-
-    throw new Error(`Unknown seat 3 action '${action}'. Try \`muuuuse stop\` or \`muuuuse status\`.`);
-  }
-
   throw new Error(`Unknown command '${command}'.`);
 }
 
-function runDoctor() {
-  const checks = [
-    checkBinary("node", ["--version"], true),
-    checkBinary("npm", ["--version"], true),
-    checkBinary("codex", ["--version"], false),
-    checkBinary("claude", ["--version"], false),
-    checkBinary("gemini", ["--version"], false),
-  ];
-
-  process.stdout.write(`${BRAND} doctor\n\n`);
-  for (const item of checks) {
-    process.stdout.write(`${item.ok ? "OK " : "MISS"} ${item.label}${item.detail ? `: ${item.detail}` : ""}\n`);
-  }
-
-  process.stdout.write("\nKnown presets\n");
-  process.stdout.write("- codex\n");
-  process.stdout.write("- claude\n");
-  process.stdout.write("- gemini\n");
-  process.stdout.write("\nAny other local program can be wrapped directly with `muuuuse 1 <program...>` or `muuuuse 2 <program...>`.\n");
-
-  const missingRequired = checks.some((item) => item.required && !item.ok);
-  if (missingRequired) {
-    process.exitCode = 1;
-  }
-}
-
-function checkBinary(command, versionArgs, required) {
-  if (!commandExists(command)) {
-    return { label: command, ok: false, detail: "not installed", required };
-  }
-  const version = readCommandVersion(command, versionArgs) || "installed";
-  return { label: command, ok: true, detail: version, required };
-}
-
-function describeStopResult(signaled, forced) {
-  if (forced) {
-    return "killed";
-  }
-  if (signaled) {
-    return "signaled";
-  }
-  return "idle";
-}
-
-function printSessionStatus(status) {
-  process.stdout.write(`${BRAND} session ${status.sessionName}\n`);
-  for (const seat of status.seats) {
-    if (!seat.status) {
-      process.stdout.write(`seat ${seat.seatId}: idle\n`);
-      continue;
-    }
-
-    const state = seat.status.state || "unknown";
-    const program = Array.isArray(seat.status.command) ? seat.status.command.join(" ") : "";
-    process.stdout.write(`seat ${seat.seatId}: ${state}${program ? ` (${program})` : ""}\n`);
-  }
+function describeStopResult(signaled) {
+  return signaled ? "signaled" : "idle";
 }
 
 module.exports = {
   main,
-  runDoctor,
 };