muuuuse 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 lmtlssss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,117 @@
-# muuuuse
+# 🔌Muuuuse
 
-Reserved npm handle for the Muuuuse local multi-seat lane.
+`muuuuse` installs one CLI name:
 
-This package currently exists to reserve the npm namespace for the corresponding lmtlssss project lane.
+- `muuuuse`
+
+The visible product brand is always `🔌Muuuuse`, while the terminal command examples use `muuuuse`.
+
+## What It Does
+
+`🔌Muuuuse` is the small local-only relay for three tmux terminals:
+
+- seat `1` listens in one terminal
+- seat `2` listens in another terminal
+- seat `3` is the controller that auto-pairs them
+
+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.
+
+Remote control is intentionally out of scope here. Use `codeman` or `codemansbot` for remote routing.
+
+## Install
+
+```bash
+npm install -g muuuuse
+```
+
+## Basic Flow
+
+Terminal 1:
+
+```bash
+muuuuse 1
+codex -m gpt-5.4 -c model_reasoning_effort=low --dangerously-bypass-approvals-and-sandbox --no-alt-screen
+```
+
+Terminal 2:
+
+```bash
+muuuuse 2
+claude --dangerously-skip-permissions --permission-mode bypassPermissions
+```
+
+Terminal 3:
+
+```bash
+muuuuse 3 "Start by proposing the first concrete repo task."
+```
+
+That third command auto-pairs seats `1` and `2`, then optionally drops a one-time kickoff prompt into seat `1`.
+
+## 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.
+
+Recommended god-mode launches:
+
+```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
+```
+
+## Script Mode
+
+Turn an armed seat into a deterministic responder:
+
+```bash
+muuuuse script
+```
+
+That stores one repeating response.
+
+For a loop of multiple steps:
+
+```bash
+muuuuse script 4
+```
+
+That collects four prompts and cycles them forever, one per inbound turn.
+
+To leave script mode and go back to a live CLI listener:
+
+```bash
+muuuuse live
+```
+
+## Requirements
+
+- `tmux`
+- `git`
+- `npm`
+- at least one local CLI you want to mirror: `codex`, `claude`, `gemini`, or script mode
+
+## Doctor
+
+```bash
+muuuuse doctor
+```
+
+This checks:
+
+- `git`
+- `npm`
+- `tmux`
+- `codex`
+- `claude`
+- `gemini`
+- `/root/npm.txt` or the fallback npm token path
+
+## 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

package/bin/muuse.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+const { main } = require("../src/cli");
+
+main().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`🔌Muuuuse error: ${message}`);
+  process.exit(1);
+});

package/package.json

@@ -1,16 +1,45 @@
 {
   "name": "muuuuse",
-  "version": "0.1.0",
-  "description": "Reserved npm handle for the Muuuuse local multi-seat lane.",
-  "license": "MIT",
+  "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.",
+  "type": "commonjs",
+  "bin": {
+    "muuuuse": "bin/muuse.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://muuuuse.lmtlssss.fun",
   "repository": {
     "type": "git",
-    "url": "https://github.com/lmtlssss/muuuuse.git"
+    "url": "git+https://github.com/lmtlssss/muuuuse.git"
   },
-  "homepage": "https://lmtlssss.fun/",
+  "bugs": {
+    "url": "https://github.com/lmtlssss/muuuuse/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
   "keywords": [
-    "lmtlssss",
-    "reserved-handle"
+    "terminal",
+    "ai",
+    "tmux",
+    "relay",
+    "local",
+    "codex",
+    "claude",
+    "gemini"
   ],
-  "main": "index.js"
+  "scripts": {
+    "test": "node test/cli.test.js",
+    "pack:local": "npm pack",
+    "prepublishOnly": "npm test"
+  }
 }

package/src/agents.js

@@ -0,0 +1,445 @@
+const { createHash } = require("node:crypto");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+
+const {
+  SESSION_MATCH_WINDOW_MS,
+  getFileSize,
+  hashText,
+  readAppendedText,
+  sanitizeRelayText,
+} = require("./util");
+
+const PRESETS = {
+  codex: {
+    label: "Codex",
+    command: [
+      "codex",
+      "-m",
+      "gpt-5.4",
+      "-c",
+      "model_reasoning_effort=low",
+      "--dangerously-bypass-approvals-and-sandbox",
+      "--no-alt-screen",
+    ],
+  },
+  claude: {
+    label: "Claude Code",
+    command: [
+      "claude",
+      "--dangerously-skip-permissions",
+      "--permission-mode",
+      "bypassPermissions",
+    ],
+  },
+  gemini: {
+    label: "Gemini CLI",
+    command: [
+      "gemini",
+      "--approval-mode",
+      "yolo",
+      "--sandbox=false",
+    ],
+  },
+};
+
+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();
+
+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 (error) {
+    return results;
+  }
+
+  return results;
+}
+
+function commandMatches(args, command) {
+  const pattern = new RegExp(`(^|[\\\\/\\s])${command}(\\s|$)`, "i");
+  return pattern.test(args);
+}
+
+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 buildDetectedAgent(type, process) {
+  return {
+    type,
+    pid: process.pid,
+    args: process.args,
+    elapsedSeconds: process.elapsedSeconds,
+    processStartedAtMs: Date.now() - process.elapsedSeconds * 1000,
+  };
+}
+
+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 chooseCandidate(candidates, currentPath, processStartedAtMs) {
+  const cwdMatches = candidates.filter((candidate) => candidate.cwd === currentPath);
+  if (cwdMatches.length === 0) {
+    return null;
+  }
+
+  if (processStartedAtMs !== null) {
+    const preciseMatches = cwdMatches
+      .map((candidate) => ({
+        ...candidate,
+        diffMs: Math.abs(candidate.startedAtMs - 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) {
+      return preciseMatches[0].path;
+    }
+  }
+
+  const fallback = cwdMatches.sort((left, right) => right.mtimeMs - left.mtimeMs)[0];
+  return fallback ? fallback.path : null;
+}
+
+function extractThreadId(filePath) {
+  const match = path.basename(filePath).match(/([0-9a-f]{8}-[0-9a-f-]{27})\.jsonl$/i);
+  return match ? match[1] : null;
+}
+
+function readCodexSnapshotPane(threadId) {
+  if (!threadId) {
+    return null;
+  }
+
+  if (codexSnapshotPaneCache.has(threadId)) {
+    return codexSnapshotPaneCache.get(threadId);
+  }
+
+  const snapshotPath = path.join(CODEX_SNAPSHOT_ROOT, `${threadId}.sh`);
+  try {
+    const contents = fs.readFileSync(snapshotPath, "utf8");
+    const match = contents.match(/declare -x TMUX_PANE="([^"]+)"/);
+    const paneId = match ? match[1] : null;
+    codexSnapshotPaneCache.set(threadId, paneId);
+    return paneId;
+  } catch (error) {
+    codexSnapshotPaneCache.set(threadId, null);
+    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,
+      threadId: extractThreadId(filePath),
+      snapshotPaneId: readCodexSnapshotPane(extractThreadId(filePath)),
+      cwd: entry.payload.cwd,
+      startedAtMs: Date.parse(entry.payload.timestamp),
+      mtimeMs: fs.statSync(filePath).mtimeMs,
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+function selectCodexSessionFile(currentPath, processStartedAtMs, paneId = null) {
+  const candidates = walkFiles(CODEX_ROOT, (filePath) => filePath.endsWith(".jsonl"))
+    .map((filePath) => readCodexCandidate(filePath))
+    .filter((candidate) => candidate !== null);
+
+  let scopedCandidates = candidates;
+  if (paneId) {
+    const exactPaneMatches = scopedCandidates.filter((candidate) => candidate.snapshotPaneId === paneId);
+    if (exactPaneMatches.length > 0) {
+      scopedCandidates = exactPaneMatches;
+    } else {
+      scopedCandidates = scopedCandidates.filter((candidate) => candidate.snapshotPaneId === null);
+    }
+  }
+
+  return chooseCandidate(scopedCandidates, 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;
+    }
+
+    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 (error) {
+    return null;
+  }
+}
+
+function readCodexAnswers(filePath, offset) {
+  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);
+
+  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 (error) {
+    return null;
+  }
+}
+
+function selectClaudeSessionFile(currentPath, processStartedAtMs) {
+  const candidates = walkFiles(CLAUDE_ROOT, (filePath) => filePath.endsWith(".jsonl"))
+    .map((filePath) => readClaudeCandidate(filePath))
+    .filter((candidate) => candidate !== null);
+
+  return chooseCandidate(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 (error) {
+    return null;
+  }
+}
+
+function readClaudeAnswers(filePath, offset) {
+  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);
+
+  return { nextOffset, answers };
+}
+
+function readGeminiCandidate(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const entry = JSON.parse(raw);
+    return {
+      path: filePath,
+      projectHash: entry.projectHash,
+      cwdHash: entry.projectHash,
+      startedAtMs: Date.parse(entry.startTime),
+      mtimeMs: fs.statSync(filePath).mtimeMs,
+      lastUpdatedMs: Date.parse(entry.lastUpdated),
+    };
+  } catch (error) {
+    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);
+
+  if (candidates.length === 0) {
+    return null;
+  }
+
+  if (processStartedAtMs !== null) {
+    const preciseMatches = candidates
+      .map((candidate) => ({
+        ...candidate,
+        diffMs: Math.abs(candidate.startedAtMs - 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) {
+      return preciseMatches[0].path;
+    }
+  }
+
+  return candidates.sort((left, right) => right.lastUpdatedMs - left.lastUpdatedMs || right.mtimeMs - left.mtimeMs)[0].path;
+}
+
+function readGeminiAnswers(filePath, lastMessageId = 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),
+      lastMessageId: finalMessages.length > 0 ? finalMessages[finalMessages.length - 1].id : lastMessageId,
+      fileSize: getFileSize(filePath),
+    };
+  } catch (error) {
+    return {
+      answers: [],
+      lastMessageId,
+      fileSize: 0,
+    };
+  }
+}
+
+module.exports = {
+  PRESETS,
+  detectAgent,
+  parseClaudeFinalLine,
+  parseCodexFinalLine,
+  readClaudeAnswers,
+  readCodexAnswers,
+  readGeminiAnswers,
+  selectClaudeSessionFile,
+  selectCodexSessionFile,
+  selectGeminiSessionFile,
+};