muuuuse 3.3.4 → 3.3.6

package/package.json

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

package/src/agents.js

@@ -179,22 +179,73 @@ function readCodexSeatClaim(sessionId) {
     return null;
   }
 
-  const snapshotPath = path.join(CODEX_SNAPSHOT_ROOT, `${sessionId}.sh`);
+  const claims = readCodexSeatClaims(sessionId);
+  return claims[0] || null;
+}
+
+function readCodexSeatClaims(sessionId) {
+  if (!sessionId) {
+    return [];
+  }
+
+  const candidatePaths = listCodexSnapshotPaths(sessionId);
+  return candidatePaths
+    .map((snapshotPath) => {
+      let text;
+      try {
+        text = fs.readFileSync(snapshotPath, "utf8");
+      } catch {
+        return null;
+      }
+
+      const seatMatch = text.match(/declare -x MUUUUSE_SEAT="([^"]+)"/);
+      const sessionMatch = text.match(/declare -x MUUUUSE_SESSION="([^"]+)"/);
+      if (!seatMatch || !sessionMatch) {
+        return null;
+      }
+
+      let mtimeMs = 0;
+      try {
+        mtimeMs = fs.statSync(snapshotPath).mtimeMs;
+      } catch {
+        // Best effort only.
+      }
+
+      return {
+        seatId: seatMatch[1],
+        sessionName: sessionMatch[1],
+        snapshotPath,
+        mtimeMs,
+      };
+    })
+    .filter((claim) => claim !== null)
+    .sort((left, right) => right.mtimeMs - left.mtimeMs || left.snapshotPath.localeCompare(right.snapshotPath));
+}
+
+function listCodexSnapshotPaths(sessionId) {
+  const exactName = `${sessionId}.sh`;
+  const prefix = `${sessionId}.`;
+  const candidateNames = [];
+
   try {
-    const text = fs.readFileSync(snapshotPath, "utf8");
-    const seatMatch = text.match(/declare -x MUUUUSE_SEAT="([^"]+)"/);
-    const sessionMatch = text.match(/declare -x MUUUUSE_SESSION="([^"]+)"/);
-    if (!seatMatch || !sessionMatch) {
-      return null;
-    }
+    for (const entry of fs.readdirSync(CODEX_SNAPSHOT_ROOT, { withFileTypes: true })) {
+      if (!entry.isFile()) {
+        continue;
+      }
 
-    return {
-      seatId: seatMatch[1],
-      sessionName: sessionMatch[1],
-    };
+      if (entry.name === exactName || (entry.name.startsWith(prefix) && entry.name.endsWith(".sh"))) {
+        candidateNames.push(entry.name);
+      }
+    }
   } catch {
-    return null;
+    // Snapshot directory may not exist yet.
   }
+
+  return uniquePaths(candidateNames.map((name) => path.join(CODEX_SNAPSHOT_ROOT, name)));
+}
+
+function candidateHasClaim(candidate, predicate) {
+  return readCodexSeatClaims(candidate.sessionId).some((claim) => predicate(claim));
 }
 
 function selectClaimedCodexCandidatePath(candidates, options = {}) {
@@ -204,29 +255,28 @@ function selectClaimedCodexCandidatePath(candidates, options = {}) {
     return null;
   }
 
-  const annotated = candidates.map((candidate) => ({
-    ...candidate,
-    claim: readCodexSeatClaim(candidate.sessionId),
-  }));
-
-  const exactMatches = annotated.filter((candidate) => (
-    candidate.claim?.seatId === seatId &&
-    candidate.claim?.sessionName === sessionName
+  const exactMatches = candidates.filter((candidate) => (
+    candidateHasClaim(candidate, (claim) => (
+      claim.seatId === seatId &&
+      claim.sessionName === sessionName
+    ))
   ));
   if (exactMatches.length === 1) {
     return exactMatches[0].path;
   }
 
-  const otherSeatClaims = annotated.filter((candidate) => (
-    candidate.claim?.sessionName === sessionName &&
-    candidate.claim?.seatId !== seatId
+  const otherSeatClaims = candidates.filter((candidate) => (
+    candidateHasClaim(candidate, (claim) => (
+      claim.sessionName === sessionName &&
+      claim.seatId !== seatId
+    ))
   ));
   if (otherSeatClaims.length === 0) {
     return null;
   }
 
   const foreignPaths = new Set(otherSeatClaims.map((candidate) => candidate.path));
-  const remaining = annotated.filter((candidate) => !foreignPaths.has(candidate.path));
+  const remaining = candidates.filter((candidate) => !foreignPaths.has(candidate.path));
   if (remaining.length === 1) {
     return remaining[0].path;
   }
@@ -332,8 +382,10 @@ function selectExactClaimedCodexCandidate(candidates, options = {}, processStart
 
   const exactMatches = rankCodexCandidates(
     candidates.filter((candidate) => {
-      const claim = readCodexSeatClaim(candidate.sessionId);
-      return claim?.seatId === seatId && claim?.sessionName === sessionName;
+      return candidateHasClaim(candidate, (claim) => (
+        claim.seatId === seatId &&
+        claim.sessionName === sessionName
+      ));
     }),
     processStartedAtMs
   );
@@ -349,8 +401,11 @@ function filterForeignClaimedCodexCandidates(candidates, options = {}) {
   }
 
   return candidates.filter((candidate) => {
-    const claim = readCodexSeatClaim(candidate.sessionId);
-    return !(claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId);
+    return !candidateHasClaim(candidate, (claim) => (
+      claim.sessionName === sessionName &&
+      claim.seatId &&
+      claim.seatId !== seatId
+    ));
   });
 }
 
@@ -391,8 +446,11 @@ function selectCodexCandidatePath(candidates, currentPath, processStartedAtMs, o
     seatId &&
     sessionName &&
     cwdMatches.some((candidate) => {
-      const claim = readCodexSeatClaim(candidate.sessionId);
-      return claim?.sessionName === sessionName && claim?.seatId && claim.seatId !== seatId;
+      return candidateHasClaim(candidate, (claim) => (
+        claim.sessionName === sessionName &&
+        claim.seatId &&
+        claim.seatId !== seatId
+      ));
     })
   );
   const allowedMatches = filterForeignClaimedCodexCandidates(cwdMatches, options);

package/src/runtime.js

@@ -42,6 +42,7 @@ 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 GEMINI_PASTE_SETTLE_MS = 200;
 const BRACKETED_PASTE_START = "\u001b[200~";
 const BRACKETED_PASTE_END = "\u001b[201~";
 const GEMINI_SHARED_ENTRY_NAMES = new Set([
@@ -56,8 +57,11 @@ const EMITTED_ANSWER_TTL_MS = 5 * 60 * 1000;
 const MAX_RECENT_INBOUND_RELAYS = 12;
 const MAX_RECENT_EMITTED_ANSWERS = 48;
 const STOP_FORCE_KILL_MS = 1200;
+const STOP_PURGE_WAIT_MS = STOP_FORCE_KILL_MS + 1200;
+const STOP_PURGE_POLL_MS = 60;
 const SEAT_JOIN_WAIT_MS = 3000;
 const SEAT_JOIN_POLL_MS = 60;
+const MAX_PENDING_PASSIVE_INPUT_CHARS = 512;
 const CHILD_ENV_DROP_KEYS = [
   "CODEX_CI",
   "CODEX_MANAGED_BY_NPM",
@@ -200,6 +204,7 @@ 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);
+  fs.rmSync(targetHomeRoot, { recursive: true, force: true });
   const targetGeminiDir = ensureDir(path.join(targetHomeRoot, ".gemini"));
 
   let sourceEntries = [];
@@ -653,6 +658,103 @@ function isMeaningfulTerminalInput(input) {
   return stripPassiveTerminalInput(input).length > 0;
 }
 
+function consumeTerminalProxyInput(input, pendingPassiveInput = "") {
+  const combined = `${pendingPassiveInput}${String(input || "")}`;
+  let forwardText = "";
+  let index = 0;
+
+  while (index < combined.length) {
+    const current = combined[index];
+    if (current !== "\u001b") {
+      forwardText += current;
+      index += 1;
+      continue;
+    }
+
+    if (index + 1 >= combined.length) {
+      forwardText += current;
+      index += 1;
+      continue;
+    }
+
+    const next = combined[index + 1];
+    if (next === "]") {
+      const belIndex = combined.indexOf("\u0007", index + 2);
+      const stIndex = combined.indexOf("\u001b\\", index + 2);
+      const endIndex = (
+        belIndex !== -1 && stIndex !== -1 ? Math.min(belIndex, stIndex) :
+        belIndex !== -1 ? belIndex :
+        stIndex
+      );
+
+      if (endIndex === -1) {
+        const pending = combined.slice(index).slice(0, MAX_PENDING_PASSIVE_INPUT_CHARS);
+        return {
+          forwardText,
+          meaningful: isMeaningfulTerminalInput(forwardText),
+          pendingPassiveInput: pending,
+        };
+      }
+
+      index = endIndex + (endIndex === stIndex ? 2 : 1);
+      continue;
+    }
+
+    if (next === "[") {
+      if (index + 2 >= combined.length) {
+        return {
+          forwardText,
+          meaningful: isMeaningfulTerminalInput(forwardText),
+          pendingPassiveInput: combined.slice(index).slice(0, MAX_PENDING_PASSIVE_INPUT_CHARS),
+        };
+      }
+
+      let endIndex = index + 2;
+      while (endIndex < combined.length && !/[@-~]/.test(combined[endIndex])) {
+        endIndex += 1;
+      }
+
+      if (endIndex >= combined.length) {
+        const pending = combined.slice(index);
+        if (/^\u001b\[(?:\??[0-9;]*)?$/.test(pending)) {
+          return {
+            forwardText,
+            meaningful: isMeaningfulTerminalInput(forwardText),
+            pendingPassiveInput: pending.slice(0, MAX_PENDING_PASSIVE_INPUT_CHARS),
+          };
+        }
+
+        forwardText += pending;
+        break;
+      }
+
+      const sequence = combined.slice(index, endIndex + 1);
+      if (
+        sequence === "\u001b[I" ||
+        sequence === "\u001b[O" ||
+        /^\u001b\[\d+;\d+R$/.test(sequence) ||
+        /^\u001b\[\?[0-9;]*c$/.test(sequence)
+      ) {
+        index = endIndex + 1;
+        continue;
+      }
+
+      forwardText += sequence;
+      index = endIndex + 1;
+      continue;
+    }
+
+    forwardText += current;
+    index += 1;
+  }
+
+  return {
+    forwardText,
+    meaningful: isMeaningfulTerminalInput(forwardText),
+    pendingPassiveInput: "",
+  };
+}
+
 async function sendTextAndEnter(child, text, shouldAbort = () => false) {
   const options = typeof shouldAbort === "function" ? { shouldAbort } : (shouldAbort || {});
   const shouldStop = typeof options.shouldAbort === "function" ? options.shouldAbort : () => false;
@@ -660,7 +762,7 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
   const payload = normalizeRelayPayloadForTyping(text);
 
   if (payload.length > 0) {
-    if (agentType === "codex") {
+    if (agentType === "codex" || agentType === "gemini") {
       if (shouldStop() || !child) {
         return false;
       }
@@ -670,6 +772,10 @@ async function sendTextAndEnter(child, text, shouldAbort = () => false) {
       } catch {
         return false;
       }
+
+      if (agentType === "gemini") {
+        await sleep(GEMINI_PASTE_SETTLE_MS);
+      }
     } else {
       for (const chunk of chunkRelayPayloadForTyping(payload)) {
         if (shouldStop() || !child) {
@@ -730,6 +836,7 @@ class ArmedSeat {
     this.forceKillTimer = null;
     this.identity = loadOrCreateSeatIdentity(this.paths);
     this.lastUserInputAtMs = 0;
+    this.pendingPassiveInput = "";
     this.pendingInboundContext = null;
     this.recentInboundRelays = [];
     this.recentEmittedAnswers = [];
@@ -843,14 +950,16 @@ class ArmedSeat {
   installStdinProxy() {
     const handleData = (chunk) => {
       const chunkText = chunk.toString("utf8");
-      if (isMeaningfulTerminalInput(chunkText)) {
+      const proxyInput = consumeTerminalProxyInput(chunkText, this.pendingPassiveInput);
+      this.pendingPassiveInput = proxyInput.pendingPassiveInput;
+      if (proxyInput.meaningful) {
         this.lastUserInputAtMs = Date.now();
         this.pendingInboundContext = null;
       }
-      if (!this.child) {
+      if (!this.child || proxyInput.forwardText.length === 0) {
         return;
       }
-      this.child.write(chunkText);
+      this.child.write(proxyInput.forwardText);
     };
 
     const handleEnd = () => {
@@ -1537,6 +1646,8 @@ class ArmedSeat {
       exitedAt: new Date().toISOString(),
       state: "exited",
     });
+
+    purgeSeatTransientState(this.sessionPaths.dir, this.paths.dir, this.cwd, this.seatId);
   }
 }
 
@@ -1661,6 +1772,10 @@ function stopAllSessions() {
     }
   }
 
+  for (const session of report.sessions) {
+    finalizeStoppedSession(session);
+  }
+
   return {
     requestedAt,
     sessions: report.sessions,
@@ -1670,6 +1785,7 @@ function stopAllSessions() {
 module.exports = {
   ArmedSeat,
   buildChildEnv,
+  consumeTerminalProxyInput,
   ensureSeatGeminiCliHome,
   chunkRelayPayloadForTyping,
   getStatusReport,
@@ -1694,6 +1810,77 @@ function signalPid(pid, signal) {
   }
 }
 
+function finalizeStoppedSession(session, timeoutMs = STOP_PURGE_WAIT_MS) {
+  if (!session || !Array.isArray(session.seats) || session.seats.length === 0) {
+    return;
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const pendingSeats = session.seats.filter((seat) => isPidAlive(seat.wrapperPid) || isPidAlive(seat.childPid));
+    if (pendingSeats.length === 0) {
+      break;
+    }
+    sleepSync(STOP_PURGE_POLL_MS);
+  }
+
+  for (const seat of session.seats) {
+    if (isPidAlive(seat.childPid)) {
+      signalProcessFamily(seat.childPid, "SIGKILL");
+    }
+    if (isPidAlive(seat.wrapperPid)) {
+      signalPid(seat.wrapperPid, "SIGKILL");
+    }
+  }
+
+  sleepSync(STOP_PURGE_POLL_MS);
+
+  const sessionDir = getSessionPaths(session.sessionName).dir;
+  for (const seat of session.seats) {
+    purgeSeatTransientState(sessionDir, getSeatPaths(session.sessionName, seat.seatId).dir, seat.cwd, seat.seatId);
+  }
+}
+
+function purgeSeatTransientState(sessionDir, seatDir, cwd, seatId) {
+  let geminiSessionDir = null;
+  try {
+    fs.rmSync(seatDir, { recursive: true, force: true });
+  } catch {
+    // Best effort only.
+  }
+
+  try {
+    const homeDir = String(process.env.HOME || "").trim() || "/root";
+    const geminiSeatHome = getSeatGeminiCliHome(homeDir, cwd, seatId);
+    geminiSessionDir = path.dirname(geminiSeatHome);
+    fs.rmSync(geminiSeatHome, { recursive: true, force: true });
+  } catch {
+    // Best effort only.
+  }
+
+  if (geminiSessionDir) {
+    try {
+      const remainingGeminiSeatDirs = fs.readdirSync(geminiSessionDir, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && /^seat-\d+$/.test(entry.name));
+      if (remainingGeminiSeatDirs.length === 0) {
+        fs.rmSync(geminiSessionDir, { recursive: true, force: true });
+      }
+    } catch {
+      // Best effort only.
+    }
+  }
+
+  try {
+    const remainingSeatDirs = fs.readdirSync(sessionDir, { withFileTypes: true })
+      .filter((entry) => entry.isDirectory() && /^seat-\d+$/.test(entry.name));
+    if (remainingSeatDirs.length === 0) {
+      fs.rmSync(sessionDir, { recursive: true, force: true });
+    }
+  } catch {
+    // Best effort only.
+  }
+}
+
 function signalProcessTree(rootPid, signal) {
   const descendants = getChildProcesses(rootPid);
   let delivered = 0;