muuuuse 3.3.2 → 3.3.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "muuuuse",
-  "version": "3.3.2",
+  "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,
@@ -975,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()) {
@@ -994,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");
@@ -1551,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)));
 }
@@ -315,6 +325,7 @@ module.exports = {
   ensureDir,
   getDefaultSessionName,
   getFileSize,
+  getSeatGeminiCliHome,
   loadOrCreateSeatIdentity,
   getSeatPaths,
   getSessionPaths,