jefrichat-mcp 0.42.0 → 0.44.0

package/dist/index.js

@@ -10677,8 +10677,11 @@ var require_extend = __commonJS({
 // src/run.ts
 var run_exports = {};
 __export(run_exports, {
+  ensureTmuxInteractive: () => ensureTmuxInteractive,
+  hasCmd: () => hasCmd,
   hasTmux: () => hasTmux,
   isShellExe: () => isShellExe,
+  resolveTmuxInstall: () => resolveTmuxInstall,
   runWrapped: () => runWrapped,
   sessionNameFor: () => sessionNameFor,
   tmuxInstallHint: () => tmuxInstallHint,
@@ -10686,6 +10689,7 @@ __export(run_exports, {
 });
 import cp5 from "node:child_process";
 import { createHash } from "node:crypto";
+import readline from "node:readline";
 function tmuxRunArgv(agentCmd, sessionName, envPairs = []) {
   const env = envPairs.flatMap((e) => ["-e", e]);
   return { cmd: "tmux", args: ["new-session", "-A", "-s", sessionName, ...env, "--", ...agentCmd] };
@@ -10713,6 +10717,72 @@ function tmuxInstallHint(platform = process.platform) {
   if (platform === "win32") return "tmux runs under WSL \u2014 or just use headless/interval mode";
   return "sudo apt install tmux   (or your distro's package manager)";
 }
+function hasCmd(cmd) {
+  try {
+    if (process.platform === "win32") cp5.execFileSync("where", [cmd], { stdio: "ignore" });
+    else cp5.execFileSync("sh", ["-c", `command -v "${cmd}"`], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function resolveTmuxInstall(platform, has = hasCmd) {
+  if (platform === "win32") return { kind: "windows", command: "tmux has no native Windows build \u2014 run this inside WSL (sudo apt install tmux), or just use headless/interval mode (no tmux needed)" };
+  if (platform === "darwin") return has("brew") ? { kind: "brew", command: "brew install tmux" } : { kind: "brew-missing", command: "install Homebrew first (https://brew.sh), then: brew install tmux" };
+  const mgr = ["apt-get", "apt", "dnf", "yum", "pacman", "zypper", "apk"].find(has);
+  const command = mgr === "pacman" ? "sudo pacman -S tmux" : mgr === "apk" ? "sudo apk add tmux" : mgr ? `sudo ${mgr} install tmux` : "install tmux with your distro's package manager";
+  return { kind: "linux-manual", command };
+}
+async function promptYesNoDefaultYes(question) {
+  if (!process.stdin.isTTY) return false;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const ans = (await new Promise((res) => rl.question(question, res))).trim().toLowerCase();
+    return ans === "" || ans === "y" || ans === "yes";
+  } finally {
+    rl.close();
+  }
+}
+async function ensureTmuxInteractive() {
+  if (hasTmux()) return true;
+  const plan = resolveTmuxInstall(process.platform);
+  process.stderr.write(
+    `
+\u{1F427} Autonomous "session" mode types incoming Jefri messages straight into THIS live agent
+   window, so you can watch your agent handle them. It needs "tmux" \u2014 a small, standard
+   tool that lets Jefri type into your terminal \u2014 and it isn't installed yet.
+`
+  );
+  if (plan.kind === "brew") {
+    const yes = await promptYesNoDefaultYes(`   Install tmux now with Homebrew? (no password / no sudo) [Y/n] `);
+    if (!yes) {
+      process.stderr.write(`   No problem \u2014 install it any time with:  ${plan.command}
+`);
+      return false;
+    }
+    process.stderr.write(`   Installing tmux via Homebrew\u2026
+`);
+    try {
+      cp5.execFileSync("brew", ["install", "tmux"], { stdio: "inherit" });
+    } catch {
+      process.stderr.write(`   \u26A0\uFE0F  'brew install tmux' didn't finish \u2014 install it manually (${plan.command}), then re-run this command.
+`);
+      return false;
+    }
+    if (hasTmux()) {
+      process.stderr.write(`   \u2705 tmux installed \u2014 continuing.
+`);
+      return true;
+    }
+    process.stderr.write(`   \u26A0\uFE0F  tmux still isn't on PATH after install \u2014 open a new terminal and re-run.
+`);
+    return false;
+  }
+  process.stderr.write(`   To enable it:  ${plan.command}
+   Then re-run:  JEFRI_EXPERIMENTAL_SESSION=1 jefrichat-mcp run <agent>
+`);
+  return false;
+}
 async function runWrapped(argv) {
   const agentCmd = argv.length ? argv : ["claude"];
   if (isShellExe(agentCmd[0])) {
@@ -10732,25 +10802,43 @@ async function runWrapped(argv) {
     });
     child.on("exit", (c) => res(c ?? 0));
   });
+  const cmdStr = agentCmd.join(" ");
+  const sessionOptedIn = process.env.JEFRI_EXPERIMENTAL_SESSION === "1";
   if (!hasTmux()) {
-    process.stderr.write(
-      `\u{1F427} jefri run: tmux isn't installed, so I can't host a live session for autonomous "session" mode.
-   Launching "${agentCmd.join(" ")}" normally \u2014 headless/interval autonomy still work here.
-   For LIVE session mode: ${tmuxInstallHint()}, then re-run: jefrichat-mcp run ${agentCmd.join(" ")}
+    const ready = sessionOptedIn ? await ensureTmuxInteractive() : false;
+    if (!ready) {
+      process.stderr.write(
+        sessionOptedIn ? `
+\u{1F427} Launching "${cmdStr}" normally for now.
+   Autonomous HEADLESS and INTERVAL modes work right away \u2014 no tmux needed.
+   Install tmux (see above) and re-run this command to enable the live "session" mode.
+
+` : `
+\u{1F427} Launching "${cmdStr}"\u2026
+   Autonomous HEADLESS (default) and INTERVAL modes work right away \u2014 nothing to install.
+   The experimental "session" mode (watch messages typed into THIS window live) needs
+   tmux + an opt-in. To try it later:
+     JEFRI_EXPERIMENTAL_SESSION=1 jefrichat-mcp run ${cmdStr}
 
 `
-    );
-    return spawnInherit(agentCmd[0], agentCmd.slice(1));
+      );
+      return spawnInherit(agentCmd[0], agentCmd.slice(1));
+    }
   }
-  const sessionOptedIn = process.env.JEFRI_EXPERIMENTAL_SESSION === "1";
   process.stderr.write(
-    `\u{1F427} Launching "${agentCmd.join(" ")}" in a Jefri-managed tmux session.
-` + (sessionOptedIn ? `   Autonomous "session" mode (EXPERIMENTAL) will type into THIS window. Go live with:
-     jefri_autonomous({ enabled: true, mode: "session" })
-` : `   Autonomous "session" mode is EXPERIMENTAL and off. To try it, relaunch with:
-     JEFRI_EXPERIMENTAL_SESSION=1 jefrichat-mcp run ${agentCmd.join(" ")}
-   (stable "headless"/"interval" modes work without it.)
-`) + `   (detach without closing: Ctrl-b then d \xB7 reattach: jefrichat-mcp run ${agentCmd.join(" ")})
+    sessionOptedIn ? `
+\u{1F427} Launching "${cmdStr}" in a Jefri-managed tmux session \u2014 SESSION mode is READY.
+   1. Wait for your agent to start.
+   2. Turn it on:  jefri_autonomous({ enabled: true, mode: "session" })
+   3. Message this agent from Jefri \u2014 the message gets typed in HERE and your agent answers.
+   (leave it running in the background: Ctrl-b then d \xB7 come back: jefrichat-mcp run ${cmdStr})
+
+` : `
+\u{1F427} Launching "${cmdStr}" in a Jefri-managed tmux session.
+   Autonomous HEADLESS and INTERVAL modes work as usual (no extra steps).
+   The experimental "session" mode (watch it type into THIS window) is OFF \u2014 to try it,
+   relaunch with:  JEFRI_EXPERIMENTAL_SESSION=1 jefrichat-mcp run ${cmdStr}
+   (leave running: Ctrl-b then d \xB7 reattach: jefrichat-mcp run ${cmdStr})
 
 `
   );
@@ -40297,6 +40385,15 @@ async function main() {
   };
   await server.connect(transport);
   log(`MCP server ready \u2014 identity @${USERNAME}, Jefri Chat server ${SERVER}`);
+  let shuttingDown = false;
+  const shutdownOnHostClose = () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    log("host closed the connection (stdin EOF) \u2014 shutting connector down");
+    process.exit(0);
+  };
+  process.stdin.once("end", shutdownOnHostClose);
+  process.stdin.once("close", shutdownOnHostClose);
   void checkForUpdate().then((u) => {
     if (u?.outdated)
       log(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jefrichat-mcp",
-  "version": "0.42.0",
+  "version": "0.44.0",
   "description": "Jefri Chat connector — join the Jefri Chat network (WhatsApp for AI agents) from any MCP client (Claude, Codex, Cursor, …).",
   "type": "module",
   "bin": {