muuuuse 0.2.0 → 1.3.1

package/README.md

@@ -1,22 +1,26 @@
 # 🔌Muuuuse
 
-`muuuuse` installs one CLI name:
+`muuuuse` installs one CLI:
 
 - `muuuuse`
 
-The visible product brand is always `🔌Muuuuse`, while the terminal command examples use `muuuuse`.
+The public brand stays `🔌Muuuuse`. The terminal command stays `muuuuse`.
 
-## What It Does
+## What It Is Now
 
-`🔌Muuuuse` is the small local-only relay for three tmux terminals:
+`🔌Muuuuse` no longer expects you to arm a terminal first and launch something later.
 
-- seat `1` listens in one terminal
-- seat `2` listens in another terminal
-- seat `3` is the controller that auto-pairs them
+The main flow is:
 
-Once seats `1` and `2` are armed, you can launch Codex, Claude, Gemini, or a deterministic script inside those two terminals. `muuuuse 3` then relays only final answers between them by injecting text plus `Enter` into the opposite seat.
+```bash
+muuuuse 1 <program...>
+muuuuse 2 <program...>
+muuuuse 3 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.
 
-Remote control is intentionally out of scope here. Use `codeman` or `codemansbot` for remote routing.
+`muuuuse 3 stop` is the cleanup command for that lane.
 
 ## Install
 
@@ -24,72 +28,66 @@ Remote control is intentionally out of scope here. Use `codeman` or `codemansbot
 npm install -g muuuuse
 ```
 
-## Basic Flow
+## Fastest AI Flow
 
 Terminal 1:
 
 ```bash
-muuuuse 1
-codex -m gpt-5.4 -c model_reasoning_effort=low --dangerously-bypass-approvals-and-sandbox --no-alt-screen
+muuuuse 1 codex
 ```
 
 Terminal 2:
 
 ```bash
-muuuuse 2
-claude --dangerously-skip-permissions --permission-mode bypassPermissions
+muuuuse 2 gemini
 ```
 
 Terminal 3:
 
 ```bash
-muuuuse 3 "Start by proposing the first concrete repo task."
+muuuuse 3 stop
 ```
 
-That third command auto-pairs seats `1` and `2`, then optionally drops a one-time kickoff prompt into seat `1`.
+Known presets expand to recommended flags automatically:
 
-## Preset Launches
-
-`🔌Muuuuse` does not launch the CLIs for you anymore. It arms the terminal, watches the live process, and reads only final answers from the local transcript files.
+- `codex`
+- `claude`
+- `gemini`
 
-Recommended god-mode launches:
+So `muuuuse 1 codex` launches the fuller Codex command, not just bare `codex`.
 
-```bash
-codex -m gpt-5.4 -c model_reasoning_effort=low --dangerously-bypass-approvals-and-sandbox --no-alt-screen
-claude --dangerously-skip-permissions --permission-mode bypassPermissions
-gemini --approval-mode yolo --sandbox=false
-```
+## Generic Program Flow
 
-## Script Mode
+This is not AI-only. Any local program can be wrapped directly.
 
-Turn an armed seat into a deterministic responder:
+Example:
 
 ```bash
-muuuuse script
+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'
 ```
 
-That stores one repeating response.
+Type into one seat and the other seat will receive the relayed block.
 
-For a loop of multiple steps:
+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.
 
-```bash
-muuuuse script 4
-```
+## Sessions
 
-That collects four prompts and cycles them forever, one per inbound turn.
+Seats auto-pair by current working directory by default.
 
-To leave script mode and go back to a live CLI listener:
+If you want an explicit lane name, use:
 
 ```bash
-muuuuse live
+muuuuse 1 --session demo codex
+muuuuse 2 --session demo gemini
+muuuuse 3 --session demo stop
 ```
 
-## Requirements
+You can also inspect the lane:
 
-- `tmux`
-- `git`
-- `npm`
-- at least one local CLI you want to mirror: `codex`, `claude`, `gemini`, or script mode
+```bash
+muuuuse 3 status
+```
 
 ## Doctor
 
@@ -97,21 +95,11 @@ muuuuse live
 muuuuse doctor
 ```
 
-This checks:
-
-- `git`
-- `npm`
-- `tmux`
-- `codex`
-- `claude`
-- `gemini`
-- `/root/npm.txt` or the fallback npm token path
+This checks the local runtime plus common agent binaries if you use them.
 
 ## Notes
 
 - local only
-- auto-pair, no auth key ceremony
-- only final answers are forwarded
-- no verbose stream forwarding
-- no reasoning forwarding
-- controller exit stops the relay
+- 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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "0.2.0",
-  "description": "🔌Muuuuse links two local tmux terminals through a third control seat so Codex, Claude, Gemini, or scripts can bounce final answers forever.",
+  "version": "1.3.1",
+  "description": "🔌Muuuuse wraps two local programs and bounces final blocks between them from the terminal you launched.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"
@@ -30,9 +30,11 @@
   "keywords": [
     "terminal",
     "ai",
-    "tmux",
+    "pty",
     "relay",
     "local",
+    "automation",
+    "script",
     "codex",
     "claude",
     "gemini"
@@ -41,5 +43,8 @@
     "test": "node test/cli.test.js",
     "pack:local": "npm pack",
     "prepublishOnly": "npm test"
+  },
+  "dependencies": {
+    "node-pty": "^1.1.0"
   }
 }

package/src/agents.js

@@ -44,11 +44,39 @@ const PRESETS = {
   },
 };
 
+function expandPresetCommand(commandTokens, usePresets = true) {
+  if (!usePresets || !Array.isArray(commandTokens) || commandTokens.length !== 1) {
+    return Array.isArray(commandTokens) ? [...commandTokens] : [];
+  }
+
+  const preset = PRESETS[String(commandTokens[0] || "").toLowerCase()];
+  return preset ? [...preset.command] : [...commandTokens];
+}
+
+function detectAgentTypeFromCommand(commandTokens) {
+  const executable = path.basename(String(commandTokens?.[0] || "")).toLowerCase();
+  if (!executable) {
+    return null;
+  }
+
+  if (executable === "codex") {
+    return "codex";
+  }
+  if (executable === "claude") {
+    return "claude";
+  }
+  if (executable === "gemini") {
+    return "gemini";
+  }
+  return null;
+}
+
 const CODEX_ROOT = path.join(os.homedir(), ".codex", "sessions");
 const CLAUDE_ROOT = path.join(os.homedir(), ".claude", "projects");
 const GEMINI_ROOT = path.join(os.homedir(), ".gemini", "tmp");
 const CODEX_SNAPSHOT_ROOT = path.join(os.homedir(), ".codex", "shell_snapshots");
 const codexSnapshotPaneCache = new Map();
+const codexSnapshotExportsCache = new Map();
 
 function walkFiles(rootPath, predicate, results = []) {
   try {
@@ -130,6 +158,10 @@ function chooseCandidate(candidates, currentPath, processStartedAtMs) {
     return null;
   }
 
+  if (cwdMatches.length === 1) {
+    return cwdMatches[0].path;
+  }
+
   if (processStartedAtMs !== null) {
     const preciseMatches = cwdMatches
       .map((candidate) => ({
@@ -139,13 +171,12 @@ function chooseCandidate(candidates, currentPath, processStartedAtMs) {
       .filter((candidate) => Number.isFinite(candidate.diffMs) && candidate.diffMs <= SESSION_MATCH_WINDOW_MS)
       .sort((left, right) => left.diffMs - right.diffMs || right.mtimeMs - left.mtimeMs);
 
-    if (preciseMatches.length > 0) {
+    if (preciseMatches.length === 1) {
       return preciseMatches[0].path;
     }
   }
 
-  const fallback = cwdMatches.sort((left, right) => right.mtimeMs - left.mtimeMs)[0];
-  return fallback ? fallback.path : null;
+  return null;
 }
 
 function extractThreadId(filePath) {
@@ -175,6 +206,49 @@ function readCodexSnapshotPane(threadId) {
   }
 }
 
+function readCodexSnapshotExports(threadId) {
+  if (!threadId) {
+    return {};
+  }
+
+  if (codexSnapshotExportsCache.has(threadId)) {
+    return codexSnapshotExportsCache.get(threadId);
+  }
+
+  const snapshotPath = path.join(CODEX_SNAPSHOT_ROOT, `${threadId}.sh`);
+  try {
+    const contents = fs.readFileSync(snapshotPath, "utf8");
+    const exportsMap = {};
+    const pattern = /^declare -x ([A-Z0-9_]+)="((?:[^"\\]|\\.)*)"$/gm;
+
+    for (const match of contents.matchAll(pattern)) {
+      const [, key = "", rawValue = ""] = match;
+      exportsMap[key] = rawValue
+        .replace(/\\"/g, "\"")
+        .replace(/\\\\/g, "\\");
+    }
+
+    codexSnapshotExportsCache.set(threadId, exportsMap);
+    return exportsMap;
+  } catch (error) {
+    codexSnapshotExportsCache.set(threadId, {});
+    return {};
+  }
+}
+
+function snapshotEnvMatches(exportsMap, expectedEnv = null) {
+  if (!expectedEnv || typeof expectedEnv !== "object") {
+    return true;
+  }
+
+  return Object.entries(expectedEnv).every(([key, value]) => {
+    if (value === undefined || value === null) {
+      return true;
+    }
+    return exportsMap[key] === String(value);
+  });
+}
+
 function readCodexCandidate(filePath) {
   try {
     const [firstLine] = readFirstLines(filePath, 1);
@@ -189,6 +263,7 @@ function readCodexCandidate(filePath) {
     return {
       path: filePath,
       threadId: extractThreadId(filePath),
+      snapshotExports: readCodexSnapshotExports(extractThreadId(filePath)),
       snapshotPaneId: readCodexSnapshotPane(extractThreadId(filePath)),
       cwd: entry.payload.cwd,
       startedAtMs: Date.parse(entry.payload.timestamp),
@@ -199,12 +274,24 @@ function readCodexCandidate(filePath) {
   }
 }
 
-function selectCodexSessionFile(currentPath, processStartedAtMs, paneId = null) {
+function selectCodexSessionFile(currentPath, processStartedAtMs, options = {}) {
+  const paneId = options.paneId || null;
+  const snapshotEnv = options.snapshotEnv || null;
   const candidates = walkFiles(CODEX_ROOT, (filePath) => filePath.endsWith(".jsonl"))
     .map((filePath) => readCodexCandidate(filePath))
     .filter((candidate) => candidate !== null);
 
   let scopedCandidates = candidates;
+  if (snapshotEnv) {
+    const exactEnvMatches = scopedCandidates.filter((candidate) => snapshotEnvMatches(candidate.snapshotExports, snapshotEnv));
+    if (exactEnvMatches.length === 1) {
+      return exactEnvMatches[0].path;
+    }
+    if (exactEnvMatches.length > 1) {
+      scopedCandidates = exactEnvMatches;
+    }
+  }
+
   if (paneId) {
     const exactPaneMatches = scopedCandidates.filter((candidate) => candidate.snapshotPaneId === paneId);
     if (exactPaneMatches.length > 0) {
@@ -388,12 +475,16 @@ function selectGeminiSessionFile(currentPath, processStartedAtMs) {
       .filter((candidate) => Number.isFinite(candidate.diffMs) && candidate.diffMs <= SESSION_MATCH_WINDOW_MS)
       .sort((left, right) => left.diffMs - right.diffMs || right.lastUpdatedMs - left.lastUpdatedMs);
 
-    if (preciseMatches.length > 0) {
+    if (preciseMatches.length === 1) {
       return preciseMatches[0].path;
     }
   }
 
-  return candidates.sort((left, right) => right.lastUpdatedMs - left.lastUpdatedMs || right.mtimeMs - left.mtimeMs)[0].path;
+  if (candidates.length === 1) {
+    return candidates[0].path;
+  }
+
+  return null;
 }
 
 function readGeminiAnswers(filePath, lastMessageId = null) {
@@ -433,7 +524,10 @@ function readGeminiAnswers(filePath, lastMessageId = null) {
 
 module.exports = {
   PRESETS,
+  chooseCandidate,
   detectAgent,
+  detectAgentTypeFromCommand,
+  expandPresetCommand,
   parseClaudeFinalLine,
   parseCodexFinalLine,
   readClaudeAnswers,

package/src/cli.js

@@ -1,19 +1,17 @@
-const fs = require("node:fs");
-const path = require("node:path");
-const readline = require("node:readline/promises");
-
-const { PRESETS } = require("./agents");
-const { Controller, SeatDaemon, armSeat, configureScript, enableLiveMode } = require("./runtime");
-const { getPaneInfo, insideTmux } = require("./tmux");
 const {
   BRAND,
   commandExists,
-  findFirstExisting,
   parseFlags,
   readCommandVersion,
-  toInt,
   usage,
 } = require("./util");
+const {
+  SeatProcess,
+  readSessionStatus,
+  resolveProgramTokens,
+  resolveSessionName,
+  stopSession,
+} = require("./runtime");
 
 async function main(argv = process.argv.slice(2)) {
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
@@ -28,130 +26,67 @@ async function main(argv = process.argv.slice(2)) {
     return;
   }
 
-  if (command === "daemon") {
-    const sessionName = argv[1];
-    const seatId = toInt(argv[2], 0);
-    if (!sessionName || ![1, 2].includes(seatId)) {
-      throw new Error("daemon requires <session-name> <1|2>.");
-    }
-
-    const daemon = new SeatDaemon(sessionName, seatId);
-    const code = await daemon.run();
-    process.exit(code);
-  }
-
   if (command === "1" || command === "2") {
-    armCurrentPane(Number(command));
-    return;
-  }
-
-  if (command === "3") {
     const { positionals, flags } = parseFlags(argv.slice(1));
-    const paneInfo = requireTmuxPane();
-    const seedText = positionals.join(" ").trim();
-    const controller = new Controller(paneInfo.sessionName, {
-      seedSeat: flags.seedSeat,
-      seedText,
+    const sessionName = resolveSessionName(flags.session, process.cwd());
+    const commandTokens = resolveProgramTokens(positionals, !flags.noPreset);
+    const seat = new SeatProcess({
+      commandTokens,
+      cwd: process.cwd(),
       maxRelays: flags.maxRelays,
+      seatId: Number(command),
+      sessionName,
     });
-    const code = await controller.run();
+    const code = await seat.run();
     process.exit(code);
   }
 
-  if (command === "script") {
-    await setScriptMode(argv.slice(1));
-    return;
-  }
-
-  if (command === "live") {
-    const paneInfo = requireTmuxPane();
-    const seat = enableLiveMode({
-      sessionName: paneInfo.sessionName,
-      paneId: paneInfo.paneId,
-    });
-    process.stdout.write(`${BRAND} seat ${seat.seatId} is back in live-listen mode.\n`);
-    return;
-  }
-
-  throw new Error(`Unknown command '${command}'.`);
-}
-
-function requireTmuxPane() {
-  if (!insideTmux()) {
-    throw new Error("muuuuse must run inside tmux so it can arm and inject the current pane.");
-  }
-
-  const paneInfo = getPaneInfo();
-  if (!paneInfo) {
-    throw new Error("tmux is active, but the current pane could not be resolved.");
-  }
-  return paneInfo;
-}
-
-function armCurrentPane(seatId) {
-  const paneInfo = requireTmuxPane();
-  const binPath = path.resolve(__dirname, "..", "bin", "muuse.js");
-  const meta = armSeat({
-    seatId,
-    paneInfo,
-    binPath,
-  });
-
-  process.stdout.write(`${BRAND} armed seat ${seatId} in tmux session ${meta.sessionName}.\n`);
-  process.stdout.write(`Pane: ${meta.paneId}\n`);
-  process.stdout.write(`Path: ${meta.cwd}\n`);
-  process.stdout.write("\nLaunch one of these in this same terminal whenever you're ready:\n");
-  for (const preset of Object.values(PRESETS)) {
-    process.stdout.write(`- ${preset.command.join(" ")}\n`);
-  }
-  process.stdout.write("\nOr switch this seat to deterministic mode with `muuuuse script`.\n");
-}
-
-async function setScriptMode(argv) {
-  const paneInfo = requireTmuxPane();
-  const { positionals, flags } = parseFlags(argv);
-  const count = Math.max(1, toInt(positionals[0] || 1, 1));
-  const steps = [...flags.step];
-
-  if (steps.length < count) {
-    const rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout,
-    });
+  if (command === "3") {
+    const { positionals, flags } = parseFlags(argv.slice(1));
+    const sessionName = resolveSessionName(flags.session, process.cwd());
+    const action = String(positionals[0] || "status").toLowerCase();
+
+    if (action === "stop") {
+      const result = stopSession(sessionName);
+      process.stdout.write(`${BRAND} stop requested for session ${result.sessionName}.\n`);
+      for (const seat of result.seats) {
+        process.stdout.write(
+          `seat ${seat.seatId}: wrapper ${seat.wrapperStopped ? "signaled" : "idle"}`
+          + `, child ${seat.childStopped ? "signaled" : "idle"}\n`
+        );
+      }
+      return;
+    }
 
-    try {
-      while (steps.length < count) {
-        const answer = (await rl.question(`Script step ${steps.length + 1}/${count}: `)).trim();
-        if (!answer) {
-          process.stdout.write("Step cannot be empty.\n");
+    if (action === "status") {
+      const status = readSessionStatus(sessionName);
+      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;
         }
-        steps.push(answer);
+
+        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`);
       }
-    } finally {
-      rl.close();
+      return;
     }
-  }
 
-  const result = configureScript({
-    sessionName: paneInfo.sessionName,
-    paneId: paneInfo.paneId,
-    steps: steps.slice(0, count),
-  });
+    throw new Error(`Unknown seat 3 action '${action}'. Try \`muuuuse 3 stop\` or \`muuuuse 3 status\`.`);
+  }
 
-  process.stdout.write(`${BRAND} seat ${result.seatId} is now in script mode with ${result.steps.length} step`);
-  process.stdout.write(result.steps.length === 1 ? ".\n" : "s.\n");
+  throw new Error(`Unknown command '${command}'.`);
 }
 
 function runDoctor() {
   const checks = [
-    checkBinary("git", ["--version"], true),
+    checkBinary("node", ["--version"], true),
     checkBinary("npm", ["--version"], true),
-    checkBinary("tmux", ["-V"], true),
     checkBinary("codex", ["--version"], false),
     checkBinary("claude", ["--version"], false),
     checkBinary("gemini", ["--version"], false),
-    checkPath("npm token file", findFirstExisting(["/root/npm.txt", "/root/_ops-bank/credentials/npm.txt"]), true),
   ];
 
   process.stdout.write(`${BRAND} doctor\n\n`);
@@ -159,12 +94,11 @@ function runDoctor() {
     process.stdout.write(`${item.ok ? "OK " : "MISS"} ${item.label}${item.detail ? `: ${item.detail}` : ""}\n`);
   }
 
-  process.stdout.write("\nLaunch presets\n");
-  for (const [name, preset] of Object.entries(PRESETS)) {
-    process.stdout.write(`- ${name}: ${preset.command.join(" ")}\n`);
-  }
-
-  process.stdout.write("\nRemote routing lives in Codeman / codemansbot. This package stays local-only.\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) {
@@ -180,13 +114,6 @@ function checkBinary(command, versionArgs, required) {
   return { label: command, ok: true, detail: version, required };
 }
 
-function checkPath(label, filePath, required) {
-  if (!filePath || !fs.existsSync(filePath)) {
-    return { label, ok: false, detail: "not found", required };
-  }
-  return { label, ok: true, detail: filePath, required };
-}
-
 module.exports = {
   main,
   runDoctor,