muuuuse 3.3.1 → 3.3.3

package/README.md

@@ -45,7 +45,7 @@ Terminal 2:
 muuuuse 2 link 1 flow off link 3 flow on link 4 flow on
 ```
 
-Now both shells are armed in the same cwd and join the same relay graph. Every seat has its own Ed25519 keypair. Each forwarded relay is signed by the sending seat. A target seat only accepts inbound relays from seats it links back to, so the graph can be open-ended without becoming an all-to-all broadcast.
+Now both shells are armed in the same cwd and join the same relay graph. Every seat has its own Ed25519 keypair. Each forwarded relay is signed by the sending seat. A target seat only accepts inbound relays when the sender linked to that target, so the graph can be open-ended without becoming an all-to-all broadcast.
 
 `link <seat> flow on` means that outbound edge sends commentary and final answers. `link <seat> flow off` means that outbound edge sends final answers only. This is sender-side routing, not receiver-side filtering.
 
@@ -79,7 +79,7 @@ muuuuse stop
 
 - state lives under `~/.muuuuse`
 - all armed seats in the same cwd share one relay session graph
-- only signed relays from reciprocally linked seats are accepted
+- only signed relays from senders that linked the target seat are accepted
 - `continue <seat>` is a convenience alias for a single signed outbound link
 - supported relay detection is built for Codex, Claude, and Gemini
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muuuuse",
-  "version": "3.3.1",
+  "version": "3.3.3",
   "description": "🔌Muuuuse arms regular terminals and relays assistant output across signed terminal links.",
   "type": "commonjs",
   "bin": {

package/src/agents.js

@@ -5,6 +5,7 @@ const path = require("node:path");
 
 const {
   getFileSize,
+  getSeatGeminiCliHome,
   hashText,
   readAppendedText,
   sanitizeRelayText,
@@ -18,6 +19,23 @@ const GEMINI_ROOT = path.join(os.homedir(), ".gemini", "tmp");
 const SESSION_START_EARLY_TOLERANCE_MS = 2 * 1000;
 const STRICT_SINGLE_CANDIDATE_EARLY_TOLERANCE_MS = 250;
 
+function uniquePaths(paths) {
+  return [...new Set(paths.map((entry) => path.resolve(entry)))];
+}
+
+function getGeminiRoots(currentPath, options = {}) {
+  const roots = [GEMINI_ROOT];
+  const seatId = Number.parseInt(String(options.seatId || "").trim(), 10);
+  if (Number.isInteger(seatId) && seatId > 0) {
+    roots.unshift(path.join(
+      getSeatGeminiCliHome(os.homedir(), currentPath, seatId),
+      ".gemini",
+      "tmp"
+    ));
+  }
+  return uniquePaths(roots);
+}
+
 function walkFiles(rootPath, predicate, results = []) {
   try {
     const entries = fs.readdirSync(rootPath, { withFileTypes: true });
@@ -642,14 +660,17 @@ function readGeminiCandidate(filePath) {
 
 function selectGeminiSessionFile(currentPath, processStartedAtMs, options = {}) {
   const projectHash = createHash("sha256").update(currentPath).digest("hex");
-  const liveCandidates = readOpenSessionCandidates(options.pids ?? options.pid, GEMINI_ROOT, readGeminiCandidate)
+  const geminiRoots = getGeminiRoots(currentPath, options);
+  const liveCandidates = geminiRoots
+    .flatMap((rootPath) => readOpenSessionCandidates(options.pids ?? options.pid, rootPath, readGeminiCandidate))
     .filter((candidate) => candidate.projectHash === projectHash);
   const livePath = selectLiveSessionCandidatePath(liveCandidates, projectHash, options.captureSinceMs);
   if (livePath) {
     return livePath;
   }
 
-  const candidates = walkFiles(GEMINI_ROOT, (filePath) => filePath.endsWith(".json"))
+  const candidates = geminiRoots
+    .flatMap((rootPath) => walkFiles(rootPath, (filePath) => filePath.endsWith(".json")))
     .map((filePath) => readGeminiCandidate(filePath))
     .filter((candidate) => candidate !== null && candidate.projectHash === projectHash);
 

package/src/runtime.js

@@ -20,6 +20,7 @@ const {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  getSeatGeminiCliHome,
   getSeatPaths,
   getSessionPaths,
   getStateRoot,
@@ -41,6 +42,14 @@ const {
 // A short settle delay keeps interactive CLIs from treating submit as another newline.
 const TYPE_CHUNK_DELAY_MS = 45;
 const TYPE_CHUNK_SIZE = 24;
+const BRACKETED_PASTE_START = "\u001b[200~";
+const BRACKETED_PASTE_END = "\u001b[201~";
+const GEMINI_SHARED_ENTRY_NAMES = new Set([
+  "gemini-credentials.json",
+  "google_accounts.json",
+  "installation_id",
+  "mcp-oauth-tokens-v2.json",
+]);
 const MIRROR_SUPPRESSION_WINDOW_MS = 30 * 1000;
 const PENDING_RELAY_CONTEXT_TTL_MS = 2 * 60 * 1000;
 const EMITTED_ANSWER_TTL_MS = 5 * 60 * 1000;
@@ -144,6 +153,78 @@ function sanitizeChildPath(pathValue, homeDir) {
   return entries.join(path.delimiter);
 }
 
+function readGeminiApiKeyFromHome(homeDir) {
+  const filePath = path.join(homeDir, "gemini.txt");
+  try {
+    const value = fs.readFileSync(filePath, "utf8").trim();
+    return value || null;
+  } catch {
+    return null;
+  }
+}
+
+function syncGeminiCliHomeEntry(sourcePath, targetPath) {
+  const shouldLink = GEMINI_SHARED_ENTRY_NAMES.has(path.basename(sourcePath));
+  try {
+    if (fs.lstatSync(targetPath).isSymbolicLink() && fs.realpathSync(targetPath) === sourcePath) {
+      return;
+    }
+  } catch {
+    // Recreate the target entry below when missing or mismatched.
+  }
+
+  fs.rmSync(targetPath, { recursive: true, force: true });
+
+  const sourceStats = fs.lstatSync(sourcePath);
+  if (shouldLink) {
+    try {
+      const linkType = process.platform === "win32"
+        ? (sourceStats.isDirectory() ? "junction" : "file")
+        : undefined;
+      fs.symlinkSync(sourcePath, targetPath, linkType);
+      return;
+    } catch {
+      // Fall through to copying when symlinks are unavailable.
+    }
+  }
+
+  if (sourceStats.isDirectory()) {
+    fs.cpSync(sourcePath, targetPath, { recursive: true });
+    return;
+  }
+
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function ensureSeatGeminiCliHome(homeDir, cwd, seatId, baseEnv = process.env) {
+  const sourceHomeRoot = String(baseEnv.GEMINI_CLI_HOME || homeDir).trim() || homeDir;
+  const sourceGeminiDir = path.join(sourceHomeRoot, ".gemini");
+  const targetHomeRoot = getSeatGeminiCliHome(homeDir, cwd, seatId);
+  const targetGeminiDir = ensureDir(path.join(targetHomeRoot, ".gemini"));
+
+  let sourceEntries = [];
+  try {
+    sourceEntries = fs.readdirSync(sourceGeminiDir, { withFileTypes: true });
+  } catch {
+    ensureDir(path.join(targetGeminiDir, "tmp"));
+    return targetHomeRoot;
+  }
+
+  for (const entry of sourceEntries) {
+    if (entry.name === "tmp") {
+      continue;
+    }
+
+    syncGeminiCliHomeEntry(
+      path.join(sourceGeminiDir, entry.name),
+      path.join(targetGeminiDir, entry.name)
+    );
+  }
+
+  ensureDir(path.join(targetGeminiDir, "tmp"));
+  return targetHomeRoot;
+}
+
 function buildChildEnv(seatId, sessionName, cwd, baseEnv = process.env) {
   const env = { ...baseEnv };
   for (const key of CHILD_ENV_DROP_KEYS) {
@@ -156,6 +237,13 @@ function buildChildEnv(seatId, sessionName, cwd, baseEnv = process.env) {
   env.TERM = resolveChildTerm(baseEnv);
   env.MUUUUSE_SEAT = String(seatId);
   env.MUUUUSE_SESSION = sessionName;
+  if (!String(env.GEMINI_API_KEY || "").trim()) {
+    const homeGeminiApiKey = readGeminiApiKeyFromHome(homeDir);
+    if (homeGeminiApiKey) {
+      env.GEMINI_API_KEY = homeGeminiApiKey;
+    }
+  }
+  env.GEMINI_CLI_HOME = getSeatGeminiCliHome(homeDir, cwd, seatId);
   return env;
 }
 
@@ -566,24 +654,39 @@ function isMeaningfulTerminalInput(input) {
 }
 
 async function sendTextAndEnter(child, text, shouldAbort = () => false) {
+  const options = typeof shouldAbort === "function" ? { shouldAbort } : (shouldAbort || {});
+  const shouldStop = typeof options.shouldAbort === "function" ? options.shouldAbort : () => false;
+  const agentType = String(options.agentType || "").trim().toLowerCase() || null;
   const payload = normalizeRelayPayloadForTyping(text);
 
   if (payload.length > 0) {
-    for (const chunk of chunkRelayPayloadForTyping(payload)) {
-      if (shouldAbort() || !child) {
+    if (agentType === "codex") {
+      if (shouldStop() || !child) {
         return false;
       }
 
       try {
-        child.write(chunk);
+        child.write(`${BRACKETED_PASTE_START}${payload}${BRACKETED_PASTE_END}`);
       } catch {
         return false;
       }
-      await sleep(TYPE_CHUNK_DELAY_MS);
+    } else {
+      for (const chunk of chunkRelayPayloadForTyping(payload)) {
+        if (shouldStop() || !child) {
+          return false;
+        }
+
+        try {
+          child.write(chunk);
+        } catch {
+          return false;
+        }
+        await sleep(TYPE_CHUNK_DELAY_MS);
+      }
     }
   }
 
-  if (shouldAbort() || !child) {
+  if (shouldStop() || !child) {
     return false;
   }
 
@@ -702,6 +805,12 @@ class ArmedSeat {
     const shell = resolveShell();
     const shellArgs = resolveShellArgs(shell);
     const childEnv = buildChildEnv(this.seatId, this.sessionName, this.cwd);
+    ensureSeatGeminiCliHome(
+      String(childEnv.HOME || "").trim() || process.env.HOME || "/root",
+      this.cwd,
+      this.seatId,
+      process.env
+    );
     this.child = pty.spawn(shell, shellArgs, {
       cols: process.stdout.columns || 120,
       rows: process.stdout.rows || 36,
@@ -872,13 +981,33 @@ class ArmedSeat {
     return Number.isFinite(requestedAtMs) && requestedAtMs > this.startedAtMs;
   }
 
-  hasAuthorizedSource(sourceSeatId) {
+  sourceLinksToTarget(sourceSeatId, targetSeatId = this.seatId) {
     const desiredSeatId = normalizeSeatId(sourceSeatId);
-    if (!desiredSeatId) {
+    const desiredTargetSeatId = normalizeSeatId(targetSeatId);
+    if (!desiredSeatId || !desiredTargetSeatId) {
       return false;
     }
 
-    return this.getConfiguredTargets().some((target) => target.seatId === desiredSeatId);
+    const sourcePaths = getSeatPaths(this.sessionName, desiredSeatId);
+    const sourceStatus = readJson(sourcePaths.statusPath, null);
+    const sourceMeta = readJson(sourcePaths.metaPath, null);
+    const sourceContinueSeatId = sourceStatus?.continueSeatId || sourceMeta?.continueSeatId || null;
+    const sourceContinueTargets = normalizeContinueTargets(
+      sourceStatus?.continueTargets || sourceMeta?.continueTargets
+    );
+
+    const configuredTargets = [...sourceContinueTargets];
+    if (
+      sourceContinueSeatId &&
+      !configuredTargets.some((target) => target.seatId === normalizeSeatId(sourceContinueSeatId))
+    ) {
+      configuredTargets.push({
+        seatId: normalizeSeatId(sourceContinueSeatId),
+        flowMode: normalizeFlowMode(sourceStatus?.flowMode || sourceMeta?.flowMode),
+      });
+    }
+
+    return configuredTargets.some((target) => target.seatId === desiredTargetSeatId);
   }
 
   readSourcePublicKey(sourceSeatId) {
@@ -922,7 +1051,7 @@ class ArmedSeat {
     const sourceSeatId = normalizeSeatId(entry?.sourceSeatId || entry?.seatId);
     const targetSeatId = normalizeSeatId(entry?.targetSeatId);
     const payload = sanitizeRelayText(entry?.text);
-    if (!sourceSeatId || targetSeatId !== this.seatId || !payload || !this.hasAuthorizedSource(sourceSeatId)) {
+    if (!sourceSeatId || targetSeatId !== this.seatId || !payload || !this.sourceLinksToTarget(sourceSeatId, targetSeatId)) {
       return false;
     }
 
@@ -955,6 +1084,10 @@ class ArmedSeat {
       return;
     }
 
+    const detectedRelayAgent = this.liveState.type
+      ? { type: this.liveState.type }
+      : detectAgent(getChildProcesses(this.childPid));
+
     const entries = parseContinueEntries(text, this.seatId);
     for (const entry of entries) {
       if (this.stopped || this.stopRequested()) {
@@ -974,7 +1107,10 @@ class ArmedSeat {
       const delivered = await sendTextAndEnter(
         this.child,
         payload,
-        () => this.stopped || this.stopRequested() || !this.child || Boolean(this.childExit)
+        {
+          agentType: detectedRelayAgent?.type || null,
+          shouldAbort: () => this.stopped || this.stopRequested() || !this.child || Boolean(this.childExit),
+        }
       );
       if (!delivered) {
         this.requestStop("relay_aborted");
@@ -1348,7 +1484,7 @@ class ArmedSeat {
         `Seat ${this.seatId} links signed relay targets: ${configuredTargets.map((target) => `${target.seatId}:${target.flowMode}`).join(", ")}.`
       );
     }
-    this.log("Signed relays are accepted only from seats that this seat links back to.");
+    this.log("Signed relays are accepted when the sender linked to this seat.");
     this.log("Run `muuuuse status` or `muuuuse stop` from any terminal.");
 
     try {
@@ -1531,12 +1667,14 @@ function stopAllSessions() {
 module.exports = {
   ArmedSeat,
   buildChildEnv,
+  ensureSeatGeminiCliHome,
   chunkRelayPayloadForTyping,
   getStatusReport,
   isBareEscapeInput,
   isMeaningfulTerminalInput,
   normalizeRelayPayloadForTyping,
   resolveSessionName,
+  sendTextAndEnter,
   stopAllSessions,
 };
 

package/src/util.js

@@ -154,6 +154,16 @@ function getDefaultSessionName(currentPath = process.cwd()) {
   return `${label}-${hashText(resolvedPath).slice(0, 8)}`;
 }
 
+function getSeatGeminiCliHome(homeDir = os.homedir(), currentPath = process.cwd(), seatId) {
+  return path.join(
+    homeDir,
+    ".muuuuse",
+    "gemini-cli-homes",
+    getDefaultSessionName(currentPath),
+    `seat-${seatId}`
+  );
+}
+
 function getSessionDir(sessionName) {
   return ensureDir(path.join(getStateRoot(), "sessions", slugifySegment(sessionName)));
 }
@@ -296,7 +306,7 @@ function usage() {
     "  4. `flow on` sends commentary and final answers on that edge. `flow off` sends final answers only.",
     "  5. `continue <seat>` is shorthand for one outbound link that uses the seat's default `flow on|off`.",
     "  6. Every forwarded relay is signed with the sender seat's key.",
-    "  7. A seat only accepts signed inbound relays from seats it links back to.",
+    "  7. A seat only accepts signed inbound relays when the sender linked to that seat.",
     "  8. Use those armed shells normally.",
     "  9. Run `muuuuse status` or `muuuuse stop` from any shell.",
     "",
@@ -315,6 +325,7 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  getSeatGeminiCliHome,
   loadOrCreateSeatIdentity,
   getSeatPaths,
   getSessionPaths,