muuuuse 1.4.0 → 1.4.2

package/README.md

@@ -1,36 +1,32 @@
 # 🔌Muuuuse
 
-`🔌Muuuuse` is a dead-simple terminal relay.
+`🔌Muuuuse` is a tiny no-tmux terminal relay.
 
-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
+It does one job:
+- arm terminal one with `muuuuse 1`
+- arm terminal two with `muuuuse 2`
+- watch Codex, Claude, or Gemini for real final answers
+- inject that final answer into the other armed terminal
+- keep looping until you stop it
 
-There are only three commands:
+The whole surface is:
 
 ```bash
 muuuuse 1
 muuuuse 2
+muuuuse status
 muuuuse stop
 ```
 
-No tmux.
-No program arguments.
-No status command.
-No doctor command.
-No preset logic.
-
 ## Flow
 
-Shell 1:
+Terminal 1:
 
 ```bash
 muuuuse 1
 ```
 
-Shell 2:
+Terminal 2:
 
 ```bash
 muuuuse 2
@@ -48,38 +44,29 @@ codex
 gemini
 ```
 
-Or run any other program. `🔌Muuuuse` is program-agnostic.
-
-When the running program rings the terminal bell, `🔌Muuuuse` takes the final output block for that turn and injects it into the partner seat.
+`🔌Muuuuse` tails the local session logs for supported CLIs, detects the final answer, types that answer into the other seat, and then sends Enter as a separate keystroke.
 
-Stop the whole loop from any other shell:
+Check the live state from any terminal:
 
 ```bash
-muuuuse stop
+muuuuse status
 ```
 
-## Install
+Stop the loop from any terminal, including one of the armed shells once it is back at a prompt:
 
 ```bash
-npm install -g muuuuse
+muuuuse stop
 ```
 
-## What Counts As A Relay
-
-`🔌Muuuuse` watches the armed terminal output for BEL (`\u0007`).
-
-That BEL marks the end of a turn.
-
-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
-- seat pairing defaults by current working directory
+- no tmux
 - state lives under `~/.muuuuse`
-- `codeman` remains the richer transport layer
-- `🔌Muuuuse` is the tiny relay protocol
+- supported final-answer detection is built for Codex, Claude, and Gemini
+- `codeman` remains the larger transport/control layer; `muuuuse` stays local and minimal
+
+## Install
+
+```bash
+npm install -g muuuuse
+```

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "muuuuse",
-  "version": "1.4.0",
-  "description": "🔌Muuuuse arms two raw terminals and bounces BEL-marked final output between them.",
+  "version": "1.4.2",
+  "description": "🔌Muuuuse arms two regular terminals and relays final answers between them.",
   "type": "commonjs",
   "bin": {
     "muuuuse": "bin/muuse.js"

package/src/agents.js

@@ -0,0 +1,391 @@
+const { createHash } = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const {
+  getFileSize,
+  hashText,
+  readAppendedText,
+  sanitizeRelayText,
+  SESSION_MATCH_WINDOW_MS,
+} = require("./util");
+
+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 SESSION_START_EARLY_TOLERANCE_MS = 2 * 1000;
+
+function walkFiles(rootPath, predicate, results = []) {
+  try {
+    const entries = fs.readdirSync(rootPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const absolutePath = path.join(rootPath, entry.name);
+      if (entry.isDirectory()) {
+        walkFiles(absolutePath, predicate, results);
+      } else if (predicate(absolutePath)) {
+        results.push(absolutePath);
+      }
+    }
+  } catch {
+    return results;
+  }
+
+  return results;
+}
+
+function commandMatches(args, command) {
+  const pattern = new RegExp(`(^|[\\\\/\\s])${command}(\\s|$)`, "i");
+  return pattern.test(args);
+}
+
+function buildDetectedAgent(type, process) {
+  return {
+    type,
+    pid: process.pid,
+    args: process.args,
+    cwd: process.cwd || null,
+    elapsedSeconds: process.elapsedSeconds,
+    processStartedAtMs: Date.now() - process.elapsedSeconds * 1000,
+  };
+}
+
+function detectAgent(processes) {
+  const ordered = [...processes].sort((left, right) => left.elapsedSeconds - right.elapsedSeconds);
+  for (const process of ordered) {
+    if (commandMatches(process.args, "codex")) {
+      return buildDetectedAgent("codex", process);
+    }
+    if (commandMatches(process.args, "claude")) {
+      return buildDetectedAgent("claude", process);
+    }
+    if (commandMatches(process.args, "gemini")) {
+      return buildDetectedAgent("gemini", process);
+    }
+  }
+  return null;
+}
+
+function readFirstLines(filePath, maxLines = 20) {
+  const lines = [];
+  const fd = fs.openSync(filePath, "r");
+
+  try {
+    const buffer = Buffer.alloc(16384);
+    const bytesRead = fs.readSync(fd, buffer, 0, buffer.length, 0);
+    if (bytesRead === 0) {
+      return lines;
+    }
+
+    for (const line of buffer.toString("utf8", 0, bytesRead).split("\n")) {
+      if (line.trim().length === 0) {
+        continue;
+      }
+      lines.push(line.trim());
+      if (lines.length >= maxLines) {
+        break;
+      }
+    }
+
+    return lines;
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function selectSessionCandidatePath(candidates, currentPath, processStartedAtMs) {
+  const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
+  if (cwdMatches.length === 0) {
+    return null;
+  }
+
+  if (cwdMatches.length === 1) {
+    return cwdMatches[0].path;
+  }
+
+  if (!Number.isFinite(processStartedAtMs)) {
+    return null;
+  }
+
+  const preciseMatches = cwdMatches
+    .map((candidate) => ({
+      ...candidate,
+      diffMs: Math.abs(candidate.startedAtMs - processStartedAtMs),
+      relativeStartMs: candidate.startedAtMs - processStartedAtMs,
+    }))
+    .filter((candidate) => (
+      Number.isFinite(candidate.diffMs) &&
+      Number.isFinite(candidate.relativeStartMs) &&
+      candidate.relativeStartMs >= -SESSION_START_EARLY_TOLERANCE_MS &&
+      candidate.relativeStartMs <= SESSION_MATCH_WINDOW_MS
+    ))
+    .sort((left, right) => left.diffMs - right.diffMs || right.mtimeMs - left.mtimeMs);
+
+  if (preciseMatches.length === 1) {
+    return preciseMatches[0].path;
+  }
+
+  return null;
+}
+
+function readCodexCandidate(filePath) {
+  try {
+    const [firstLine] = readFirstLines(filePath, 1);
+    if (!firstLine) {
+      return null;
+    }
+
+    const entry = JSON.parse(firstLine);
+    if (entry?.type !== "session_meta" || typeof entry.payload?.cwd !== "string") {
+      return null;
+    }
+
+    return {
+      path: filePath,
+      cwd: entry.payload.cwd,
+      startedAtMs: Date.parse(entry.payload.timestamp),
+      mtimeMs: fs.statSync(filePath).mtimeMs,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function selectCodexSessionFile(currentPath, processStartedAtMs) {
+  const candidates = walkFiles(CODEX_ROOT, (filePath) => filePath.endsWith(".jsonl"))
+    .map((filePath) => readCodexCandidate(filePath))
+    .filter((candidate) => candidate !== null);
+
+  return selectSessionCandidatePath(candidates, currentPath, processStartedAtMs);
+}
+
+function extractCodexAssistantText(content) {
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  return content
+    .flatMap((item) => {
+      if (!item || typeof item !== "object") {
+        return [];
+      }
+      if (item.type === "output_text" && typeof item.text === "string") {
+        return [item.text.trim()];
+      }
+      return [];
+    })
+    .filter((text) => text.length > 0)
+    .join("\n");
+}
+
+function parseCodexFinalLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (entry?.type !== "response_item" || entry.payload?.type !== "message" || entry.payload?.role !== "assistant") {
+      return null;
+    }
+
+    if (entry.payload?.phase !== "final_answer") {
+      return null;
+    }
+
+    const text = sanitizeRelayText(extractCodexAssistantText(entry.payload.content));
+    if (!text) {
+      return null;
+    }
+
+    return {
+      id: entry.payload.id || hashText(line),
+      text,
+      timestamp: entry.timestamp || entry.payload.timestamp || new Date().toISOString(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function isAnswerNewEnough(answer, sinceMs = null) {
+  if (!Number.isFinite(sinceMs)) {
+    return true;
+  }
+
+  const answerMs = Date.parse(answer?.timestamp || "");
+  if (!Number.isFinite(answerMs)) {
+    return true;
+  }
+
+  return answerMs >= sinceMs;
+}
+
+function readCodexAnswers(filePath, offset, sinceMs = null) {
+  const { nextOffset, text } = readAppendedText(filePath, offset);
+  const answers = text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => parseCodexFinalLine(line))
+    .filter((entry) => entry !== null)
+    .filter((entry) => isAnswerNewEnough(entry, sinceMs));
+
+  return { nextOffset, answers };
+}
+
+function readClaudeCandidate(filePath) {
+  try {
+    const lines = readFirstLines(filePath, 12);
+    for (const line of lines) {
+      const entry = JSON.parse(line);
+      if (typeof entry.cwd !== "string") {
+        continue;
+      }
+
+      return {
+        path: filePath,
+        cwd: entry.cwd,
+        startedAtMs: Date.parse(entry.timestamp || entry.message?.timestamp || 0),
+        mtimeMs: fs.statSync(filePath).mtimeMs,
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+function selectClaudeSessionFile(currentPath, processStartedAtMs) {
+  const candidates = walkFiles(CLAUDE_ROOT, (filePath) => filePath.endsWith(".jsonl"))
+    .map((filePath) => readClaudeCandidate(filePath))
+    .filter((candidate) => candidate !== null);
+
+  return selectSessionCandidatePath(candidates, currentPath, processStartedAtMs);
+}
+
+function extractClaudeAssistantText(content) {
+  if (!Array.isArray(content)) {
+    return "";
+  }
+
+  return content
+    .flatMap((item) => {
+      if (!item || typeof item !== "object") {
+        return [];
+      }
+      if (item.type === "text" && typeof item.text === "string") {
+        return [item.text.trim()];
+      }
+      return [];
+    })
+    .filter((text) => text.length > 0)
+    .join("\n");
+}
+
+function parseClaudeFinalLine(line) {
+  try {
+    const entry = JSON.parse(line);
+    if (entry?.type !== "assistant" || entry.message?.role !== "assistant" || entry.message?.stop_reason !== "end_turn") {
+      return null;
+    }
+
+    const text = sanitizeRelayText(extractClaudeAssistantText(entry.message.content));
+    if (!text) {
+      return null;
+    }
+
+    return {
+      id: entry.uuid || entry.message.id || hashText(line),
+      text,
+      timestamp: entry.timestamp || new Date().toISOString(),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function readClaudeAnswers(filePath, offset, sinceMs = null) {
+  const { nextOffset, text } = readAppendedText(filePath, offset);
+  const answers = text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0)
+    .map((line) => parseClaudeFinalLine(line))
+    .filter((entry) => entry !== null)
+    .filter((entry) => isAnswerNewEnough(entry, sinceMs));
+
+  return { nextOffset, answers };
+}
+
+function readGeminiCandidate(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const entry = JSON.parse(raw);
+    return {
+      path: filePath,
+      projectHash: entry.projectHash,
+      cwd: entry.projectHash,
+      startedAtMs: Date.parse(entry.startTime),
+      mtimeMs: fs.statSync(filePath).mtimeMs,
+      lastUpdatedMs: Date.parse(entry.lastUpdated),
+    };
+  } catch {
+    return null;
+  }
+}
+
+function selectGeminiSessionFile(currentPath, processStartedAtMs) {
+  const projectHash = createHash("sha256").update(currentPath).digest("hex");
+  const candidates = walkFiles(GEMINI_ROOT, (filePath) => filePath.endsWith(".json"))
+    .map((filePath) => readGeminiCandidate(filePath))
+    .filter((candidate) => candidate !== null && candidate.projectHash === projectHash);
+
+  return selectSessionCandidatePath(candidates, projectHash, processStartedAtMs);
+}
+
+function readGeminiAnswers(filePath, lastMessageId = null, sinceMs = null) {
+  try {
+    const entry = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    const messages = Array.isArray(entry.messages) ? entry.messages : [];
+    const finalMessages = messages.filter((message) => {
+      const toolCalls = Array.isArray(message.toolCalls) ? message.toolCalls : [];
+      return message.type === "gemini" && typeof message.content === "string" && message.content.trim() && toolCalls.length === 0;
+    });
+
+    let startIndex = 0;
+    if (lastMessageId) {
+      const previousIndex = finalMessages.findIndex((message) => message.id === lastMessageId);
+      startIndex = previousIndex === -1 ? finalMessages.length : previousIndex + 1;
+    }
+
+    const answers = finalMessages.slice(startIndex).map((message) => ({
+      id: message.id || hashText(JSON.stringify(message)),
+      text: sanitizeRelayText(message.content),
+      timestamp: message.timestamp || entry.lastUpdated || new Date().toISOString(),
+    }));
+
+    return {
+      answers: answers
+        .filter((answer) => answer.text.length > 0)
+        .filter((answer) => isAnswerNewEnough(answer, sinceMs)),
+      lastMessageId: finalMessages.length > 0 ? finalMessages[finalMessages.length - 1].id : lastMessageId,
+      fileSize: getFileSize(filePath),
+    };
+  } catch {
+    return {
+      answers: [],
+      lastMessageId,
+      fileSize: 0,
+    };
+  }
+}
+
+module.exports = {
+  detectAgent,
+  parseClaudeFinalLine,
+  parseCodexFinalLine,
+  readClaudeAnswers,
+  readCodexAnswers,
+  readGeminiAnswers,
+  selectSessionCandidatePath,
+  selectClaudeSessionFile,
+  selectCodexSessionFile,
+  selectGeminiSessionFile,
+};

package/src/cli.js

@@ -1,5 +1,5 @@
 const { BRAND, usage } = require("./util");
-const { ArmedSeat, stopAllSessions } = require("./runtime");
+const { ArmedSeat, getStatusReport, stopAllSessions } = require("./runtime");
 
 async function main(argv = process.argv.slice(2)) {
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
@@ -24,7 +24,31 @@ async function main(argv = process.argv.slice(2)) {
     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)} · child ${describeStopResult(seat.childStopped)}\n`);
+        process.stdout.write(`seat ${seat.seatId}: ${seat.state} · agent ${seat.agent || "idle"} · relays ${seat.relayCount}\n`);
+      }
+    }
+    return;
+  }
+
+  if (command === "status") {
+    if (argv.length > 1) {
+      throw new Error("`muuuuse status` takes no extra arguments.");
+    }
+
+    const report = getStatusReport();
+    if (report.sessions.length === 0) {
+      process.stdout.write(`${BRAND} no armed seats found.\n`);
+      return;
+    }
+
+    process.stdout.write(`${BRAND} status\n`);
+    for (const session of report.sessions) {
+      process.stdout.write(`\n${session.sessionName}\n`);
+      if (session.stopRequestedAt) {
+        process.stdout.write(`stop requested: ${session.stopRequestedAt}\n`);
+      }
+      for (const seat of session.seats) {
+        process.stdout.write(renderSeatStatus(seat));
       }
     }
     return;
@@ -32,7 +56,7 @@ async function main(argv = process.argv.slice(2)) {
 
   if (command === "1" || command === "2") {
     if (argv.length > 1) {
-      throw new Error(`\`muuuuse ${command}\` no longer takes a program. It arms this terminal raw.`);
+      throw new Error(`\`muuuuse ${command}\` takes no extra arguments. Run it directly in the terminal you want to arm.`);
     }
 
     const seat = new ArmedSeat({
@@ -46,8 +70,30 @@ async function main(argv = process.argv.slice(2)) {
   throw new Error(`Unknown command '${command}'.`);
 }
 
-function describeStopResult(signaled) {
-  return signaled ? "signaled" : "idle";
+function renderSeatStatus(seat) {
+  const bits = [
+    `seat ${seat.seatId}: ${seat.state}`,
+    `agent ${seat.agent || "idle"}`,
+    `relays ${seat.relayCount}`,
+    `wrapper ${seat.wrapperPid || "-"}`,
+    `child ${seat.childPid || "-"}`,
+  ];
+
+  if (seat.partnerLive) {
+    bits.push("peer live");
+  }
+  if (seat.lastAnswerAt) {
+    bits.push(`last answer ${seat.lastAnswerAt}`);
+  }
+
+  let output = `${bits.join(" · ")}\n`;
+  if (seat.cwd) {
+    output += `cwd: ${seat.cwd}\n`;
+  }
+  if (seat.log) {
+    output += `log: ${seat.log}\n`;
+  }
+  return output;
 }
 
 module.exports = {