jefrichat-mcp 0.48.6 → 0.48.7

package/dist/http.js

@@ -60976,6 +60976,28 @@ var JefriClient = class _JefriClient {
   announceHost(host) {
     const h = (host ?? "").trim();
     this.clientInfo = { ...this.clientInfo ?? { name: "jefri-sdk", version: "0" }, host: h };
+    this.sendClientInfo();
+  }
+  /** Announce WHERE this connector runs — the folder and the machine.
+   *
+   *  Separate from announceHost because the two are learned at different times
+   *  and by different means: the host app arrives from the MCP handshake, the
+   *  location is simply observed. Callers pass values they READ NOW
+   *  (process.cwd(), os.hostname()) — never a configured preference, which is
+   *  what made the old reported folder wrong. Omitted fields are left untouched
+   *  by the hub rather than cleared, so a caller that knows only one may send
+   *  only that one. */
+  announceWhere(where) {
+    const base = this.clientInfo ?? { name: "jefri-sdk", version: "0" };
+    const next = { ...base };
+    if (where.cwd !== void 0) next.cwd = (where.cwd ?? "").trim();
+    if (where.machine !== void 0) next.machine = (where.machine ?? "").trim();
+    this.clientInfo = next;
+    this.sendClientInfo();
+  }
+  /** Push the current clientInfo if the socket is live. Reconnects re-send it
+   *  from the stored copy, so a failure here is not worth reporting. */
+  sendClientInfo() {
     try {
       if (this.ws?.readyState === this.ws?.OPEN)
         this.ws.send(JSON.stringify({ type: "client_info", ...this.clientInfo }));

package/dist/index.js

@@ -10847,8 +10847,10 @@ var init_control_proto = __esm({
       // {agent?, ids?} → {unread: UnreadTally}
       "unread",
       // {} → UnreadTally
-      "subscribe"
+      "subscribe",
       // {} → {subscribed: true}; server then pushes EventFrames
+      "history"
+      // {agent, with?|groupId?, limit?} → {messages: HistoryMessage[]}
     ];
     METHOD_SET = new Set(METHODS);
     FrameDecoder = class {
@@ -11441,6 +11443,17 @@ async function openSession() {
   return {
     conns,
     agents: () => conns.flatMap((c2) => c2.agents),
+    async history(agent, q) {
+      const conn = conns.find((c2) => c2.agents.some((a) => a.username === agent)) ?? conns[0];
+      if (!conn) return [];
+      const res = await conn.request("history", {
+        agent,
+        with: q.with,
+        groupId: q.groupId,
+        limit: q.limit ?? 50
+      });
+      return res.messages ?? [];
+    },
     async inbox(limit = 50) {
       const per = await Promise.allSettled(
         conns.map((c2) => c2.request("inbox", { limit }))
@@ -12104,9 +12117,9 @@ __export(run_exports, {
   tmuxPanelSetupArgv: () => tmuxPanelSetupArgv,
   tmuxRunArgv: () => tmuxRunArgv
 });
-import cp7 from "node:child_process";
+import cp9 from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import readline from "node:readline";
+import readline2 from "node:readline";
 function tmuxRunArgv(agentCmd, sessionName, cwd, envPairs = []) {
   const env = envPairs.flatMap((e) => ["-e", e]);
   return { cmd: "tmux", args: ["new-session", "-d", "-s", sessionName, "-c", cwd, ...env, "--", ...agentCmd] };
@@ -12157,7 +12170,7 @@ function tmuxPanelSetupArgv(session, launcher, badgeScript) {
 }
 function hasTmux() {
   try {
-    cp7.execFileSync("tmux", ["-V"], { stdio: "ignore" });
+    cp9.execFileSync("tmux", ["-V"], { stdio: "ignore" });
     return true;
   } catch {
     return false;
@@ -12175,9 +12188,9 @@ function resolveTmuxInstall(platform, has = hasCmd2) {
   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) {
+async function promptYesNoDefaultYes2(question) {
   if (!process.stdin.isTTY) return false;
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const rl = readline2.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";
@@ -12196,7 +12209,7 @@ async function ensureTmuxInteractive() {
 `
   );
   if (plan.kind === "brew") {
-    const yes = await promptYesNoDefaultYes(`   Install tmux now with Homebrew? (no password / no sudo) [Y/n] `);
+    const yes = await promptYesNoDefaultYes2(`   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}
 `);
@@ -12205,7 +12218,7 @@ async function ensureTmuxInteractive() {
     process.stderr.write(`   Installing tmux via Homebrew\u2026
 `);
     try {
-      cp7.execFileSync("brew", ["install", "tmux"], { stdio: "inherit" });
+      cp9.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.
 `);
@@ -12236,7 +12249,7 @@ async function runWrapped(argv) {
     return 2;
   }
   const spawnInherit = (cmd2, args2) => new Promise((res) => {
-    const child = cp7.spawn(cmd2, args2, { stdio: "inherit" });
+    const child = cp9.spawn(cmd2, args2, { stdio: "inherit" });
     child.on("error", (e) => {
       process.stderr.write(`jefri run: could not start ${cmd2}: ${e?.message ?? e}
 `);
@@ -12287,21 +12300,21 @@ async function runWrapped(argv) {
   const cwd = process.cwd();
   const name = sessionNameFor(agentCmd, cwd, sessionOptedIn);
   const { cmd, args } = tmuxRunArgv(agentCmd, name, cwd, sessionOptedIn ? ["JEFRI_EXPERIMENTAL_SESSION=1"] : []);
-  cp7.spawnSync(cmd, args, { stdio: "ignore" });
-  cp7.spawnSync("tmux", ["set-option", "-t", name, "mouse", "on"], { stdio: "ignore" });
-  cp7.spawnSync("tmux", ["set-option", "-t", name, "set-clipboard", "on"], { stdio: "ignore" });
-  cp7.spawnSync("tmux", ["set-option", "-t", name, "history-limit", "50000"], { stdio: "ignore" });
+  cp9.spawnSync(cmd, args, { stdio: "ignore" });
+  cp9.spawnSync("tmux", ["set-option", "-t", name, "mouse", "on"], { stdio: "ignore" });
+  cp9.spawnSync("tmux", ["set-option", "-t", name, "set-clipboard", "on"], { stdio: "ignore" });
+  cp9.spawnSync("tmux", ["set-option", "-t", name, "history-limit", "50000"], { stdio: "ignore" });
   for (const table of ["copy-mode", "copy-mode-vi"]) {
-    cp7.spawnSync("tmux", ["bind-key", "-T", table, "WheelUpPane", "send-keys", "-N2", "-X", "scroll-up"], { stdio: "ignore" });
-    cp7.spawnSync("tmux", ["bind-key", "-T", table, "WheelDownPane", "send-keys", "-N2", "-X", "scroll-down"], { stdio: "ignore" });
+    cp9.spawnSync("tmux", ["bind-key", "-T", table, "WheelUpPane", "send-keys", "-N2", "-X", "scroll-up"], { stdio: "ignore" });
+    cp9.spawnSync("tmux", ["bind-key", "-T", table, "WheelDownPane", "send-keys", "-N2", "-X", "scroll-down"], { stdio: "ignore" });
     if (process.platform === "darwin")
-      cp7.spawnSync("tmux", ["bind-key", "-T", table, "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel", "pbcopy"], { stdio: "ignore" });
+      cp9.spawnSync("tmux", ["bind-key", "-T", table, "MouseDragEnd1Pane", "send-keys", "-X", "copy-pipe-and-cancel", "pbcopy"], { stdio: "ignore" });
   }
   try {
     const launcher = writePanelLauncher(`${selfCommand()} panel`);
     const badge = writeBadgeScript(UNREAD_DIR, AGENTS_DIR);
     for (const { cmd: c2, args: a2 } of tmuxPanelSetupArgv(name, launcher, badge))
-      cp7.spawnSync(c2, a2, { stdio: "ignore" });
+      cp9.spawnSync(c2, a2, { stdio: "ignore" });
     process.stderr.write(`   \u{1F4EC} Jefri panel: press Ctrl-b then j (or click the \u{1F4EC} badge) to read + reply.
 
 `);
@@ -12333,7 +12346,7 @@ __export(panel_exports, {
   runPanel: () => runPanel,
   truncateToWidth: () => truncateToWidth
 });
-import readline2 from "node:readline/promises";
+import readline3 from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
 function ago(at, now = Date.now()) {
   const s = Math.max(0, Math.round((now - at) / 1e3));
@@ -12342,15 +12355,15 @@ function ago(at, now = Date.now()) {
   if (s < 86400) return `${Math.round(s / 3600)}h`;
   return `${Math.round(s / 86400)}d`;
 }
-function charWidth(cp8) {
-  if (cp8 >= 768 && cp8 <= 879 || cp8 >= 6832 && cp8 <= 6911 || cp8 >= 7616 && cp8 <= 7679 || cp8 >= 8400 && cp8 <= 8432 || cp8 >= 65056 && cp8 <= 65071 || cp8 >= 8203 && cp8 <= 8205 || cp8 >= 65024 && cp8 <= 65039 || cp8 >= 917536 && cp8 <= 917631 || cp8 >= 917760 && cp8 <= 917999) return 0;
-  const wide = cp8 >= 4352 && cp8 <= 4447 || // Hangul Jamo
-  cp8 >= 11904 && cp8 <= 42191 && cp8 !== 12351 || // CJK radicals … Yi
-  cp8 >= 44032 && cp8 <= 55203 || // Hangul syllables
-  cp8 >= 63744 && cp8 <= 64255 || // CJK compatibility ideographs
-  cp8 >= 65040 && cp8 <= 65049 || cp8 >= 65072 && cp8 <= 65135 || cp8 >= 65280 && cp8 <= 65376 || cp8 >= 65504 && cp8 <= 65510 || cp8 >= 127462 && cp8 <= 127487 || // regional indicators (flags)
-  cp8 >= 127744 && cp8 <= 129791 || // every modern emoji block
-  cp8 >= 131072 && cp8 <= 262141;
+function charWidth(cp10) {
+  if (cp10 >= 768 && cp10 <= 879 || cp10 >= 6832 && cp10 <= 6911 || cp10 >= 7616 && cp10 <= 7679 || cp10 >= 8400 && cp10 <= 8432 || cp10 >= 65056 && cp10 <= 65071 || cp10 >= 8203 && cp10 <= 8205 || cp10 >= 65024 && cp10 <= 65039 || cp10 >= 917536 && cp10 <= 917631 || cp10 >= 917760 && cp10 <= 917999) return 0;
+  const wide = cp10 >= 4352 && cp10 <= 4447 || // Hangul Jamo
+  cp10 >= 11904 && cp10 <= 42191 && cp10 !== 12351 || // CJK radicals … Yi
+  cp10 >= 44032 && cp10 <= 55203 || // Hangul syllables
+  cp10 >= 63744 && cp10 <= 64255 || // CJK compatibility ideographs
+  cp10 >= 65040 && cp10 <= 65049 || cp10 >= 65072 && cp10 <= 65135 || cp10 >= 65280 && cp10 <= 65376 || cp10 >= 65504 && cp10 <= 65510 || cp10 >= 127462 && cp10 <= 127487 || // regional indicators (flags)
+  cp10 >= 127744 && cp10 <= 129791 || // every modern emoji block
+  cp10 >= 131072 && cp10 <= 262141;
   return wide ? 2 : 1;
 }
 function clusters(s) {
@@ -12476,7 +12489,7 @@ async function runPanel() {
     dirty = true;
   });
   await session.subscribe();
-  const rl = readline2.createInterface({ input, output });
+  const rl = readline3.createInterface({ input, output });
   const prompter = new Prompter(rl);
   let messages = [];
   const refresh = async () => {
@@ -38929,6 +38942,28 @@ var JefriClient = class _JefriClient {
   announceHost(host) {
     const h = (host ?? "").trim();
     this.clientInfo = { ...this.clientInfo ?? { name: "jefri-sdk", version: "0" }, host: h };
+    this.sendClientInfo();
+  }
+  /** Announce WHERE this connector runs — the folder and the machine.
+   *
+   *  Separate from announceHost because the two are learned at different times
+   *  and by different means: the host app arrives from the MCP handshake, the
+   *  location is simply observed. Callers pass values they READ NOW
+   *  (process.cwd(), os.hostname()) — never a configured preference, which is
+   *  what made the old reported folder wrong. Omitted fields are left untouched
+   *  by the hub rather than cleared, so a caller that knows only one may send
+   *  only that one. */
+  announceWhere(where) {
+    const base = this.clientInfo ?? { name: "jefri-sdk", version: "0" };
+    const next = { ...base };
+    if (where.cwd !== void 0) next.cwd = (where.cwd ?? "").trim();
+    if (where.machine !== void 0) next.machine = (where.machine ?? "").trim();
+    this.clientInfo = next;
+    this.sendClientInfo();
+  }
+  /** Push the current clientInfo if the socket is live. Reconnects re-send it
+   *  from the stored copy, so a failure here is not worth reporting. */
+  sendClientInfo() {
     try {
       if (this.ws?.readyState === this.ws?.OPEN)
         this.ws.send(JSON.stringify({ type: "client_info", ...this.clientInfo }));
@@ -39590,31 +39625,90 @@ function configureAuto(opts) {
 }
 var watcher = null;
 var watchDebounce = null;
+var watchRetry = null;
+var pollTimer = null;
+var pollSig = "";
+var watchAttempt = 0;
+var POLL_MS = 3e3;
+function applyConfigChange() {
+  const wasEnabled = cfg.enabled;
+  cfg = loadCfg();
+  if (cfg.enabled !== wasEnabled) logLine(`config reloaded: enabled ${wasEnabled} \u2192 ${cfg.enabled}`);
+  if (cfg.enabled) acquireResponderLock();
+  else {
+    releaseResponderLock();
+    stopAllWork();
+  }
+  ensureIntervalTimer();
+}
+function configPath() {
+  return np3.join(AUTO_DIR, `${safeUser(selfName)}.json`);
+}
+function configSignature() {
+  try {
+    const st = fs4.statSync(configPath());
+    return `${st.mtimeMs}:${st.size}`;
+  } catch {
+    return "";
+  }
+}
+function startPolling(why) {
+  if (pollTimer) return;
+  pollSig = configSignature();
+  logLine(`config hot-reload switched to polling every ${POLL_MS / 1e3}s (${why}) \u2014 no descriptors needed`);
+  pollTimer = setInterval(() => {
+    const sig = configSignature();
+    if (sig === pollSig) return;
+    pollSig = sig;
+    applyConfigChange();
+  }, POLL_MS);
+  pollTimer.unref?.();
+}
+function stopPolling() {
+  if (!pollTimer) return;
+  clearInterval(pollTimer);
+  pollTimer = null;
+}
 function watchConfig() {
   try {
     watcher?.close();
   } catch {
   }
+  watcher = null;
+  if (watchRetry) {
+    clearTimeout(watchRetry);
+    watchRetry = null;
+  }
+  const degrade = (why) => {
+    startPolling(why);
+    const delay = Math.min(3e4 * 2 ** watchAttempt++, 3e5);
+    watchRetry = setTimeout(watchConfig, delay);
+    watchRetry.unref?.();
+  };
   try {
     fs4.mkdirSync(AUTO_DIR, { recursive: true });
     const file = `${safeUser(selfName)}.json`;
-    watcher = fs4.watch(AUTO_DIR, { persistent: false }, (_evt, name) => {
+    const w = fs4.watch(AUTO_DIR, { persistent: false }, (_evt, name) => {
       if (name && name !== file) return;
       if (watchDebounce) clearTimeout(watchDebounce);
-      watchDebounce = setTimeout(() => {
-        const wasEnabled = cfg.enabled;
-        cfg = loadCfg();
-        if (cfg.enabled !== wasEnabled) logLine(`config reloaded: enabled ${wasEnabled} \u2192 ${cfg.enabled}`);
-        if (cfg.enabled) acquireResponderLock();
-        else {
-          releaseResponderLock();
-          stopAllWork();
-        }
-        ensureIntervalTimer();
-      }, 200);
+      watchDebounce = setTimeout(applyConfigChange, 200);
     });
-    watcher.unref?.();
-  } catch {
+    w.on("error", (err) => {
+      logLine(`config watch failed (${err?.code ?? err?.message ?? err}) \u2014 falling back to polling, connector unaffected`);
+      try {
+        w.close();
+      } catch {
+      }
+      if (watcher === w) watcher = null;
+      degrade(String(err?.code ?? "watch error"));
+    });
+    watcher = w;
+    watchAttempt = 0;
+    stopPolling();
+    w.unref?.();
+  } catch (e) {
+    logLine(`config watch unavailable (${e?.code ?? e?.message ?? e}) \u2014 using polling instead`);
+    degrade(String(e?.code ?? "watch unavailable"));
   }
 }
 var LOCK_STALE_MS = 9e4;
@@ -41856,6 +41950,9 @@ function attachInbox(c2, inbox2, self, onIncoming) {
   c2.on("file_received", capture);
 }
 
+// src/index.ts
+init_control_proto();
+
 // src/control.ts
 init_control_proto();
 init_registry();
@@ -41883,6 +41980,8 @@ async function startControlServer(opts) {
     owner: opts.owner ?? null,
     host: opts.getHost(),
     workdir: opts.workdir,
+    cwd: opts.cwd ?? null,
+    machine: opts.machine ?? null,
     server: opts.server,
     online: opts.isOnline(),
     unread: currentTally().total,
@@ -41944,6 +42043,19 @@ async function startControlServer(opts) {
       case "subscribe":
         c2.subscribed = true;
         return reply(c2, okRes(id, { subscribed: true }));
+      case "history": {
+        if (!opts.fetchHistory) return fail3(c2, id, "unknown_method", "history is not available from this endpoint");
+        const withUser = typeof params.with === "string" ? params.with : void 0;
+        const groupId = typeof params.groupId === "string" ? params.groupId : void 0;
+        if (!withUser && !groupId) return fail3(c2, id, "bad_request", "history needs `with` (a username) or `groupId`");
+        const limit = Math.min(Math.max(Number(params.limit) || 50, 1), 200);
+        try {
+          const messages2 = await opts.fetchHistory({ with: withUser, groupId, limit });
+          return reply(c2, okRes(id, { messages: messages2 }));
+        } catch (e) {
+          return fail3(c2, id, "internal", `history failed: ${e?.message ?? e}`);
+        }
+      }
       case "inbox": {
         const limit = Math.min(Math.max(Number(params.limit) || 50, 1), MAX_STORED);
         return reply(c2, okRes(id, { messages: messages.slice(-limit).reverse() }));
@@ -42059,7 +42171,14 @@ async function startControlServer(opts) {
     pid: process.pid,
     server: opts.server,
     host: opts.getHost(),
+    // Both, and clearly distinct. `workdir` is the brain's configured folder;
+    // `cwd` is where this process runs. The descriptor previously carried only
+    // `workdir` under a name every reader took to mean "where it runs" — which
+    // is how a stale setting ended up being handed out as the answer to "where
+    // do I go to restart this?".
     workdir: opts.workdir,
+    cwd: opts.cwd ?? null,
+    machine: opts.machine ?? null,
     startedAt: (/* @__PURE__ */ new Date()).toISOString()
   });
   writeUnreadFor(self, 0);
@@ -42139,9 +42258,150 @@ async function startControlServer(opts) {
 init_popup();
 
 // src/doctor.ts
-import cp6 from "node:child_process";
+import cp8 from "node:child_process";
 init_version();
 init_banner();
+
+// src/fdcheck.ts
+import cp6 from "node:child_process";
+function labelFor(command) {
+  if (/tsx[/\\]dist[/\\]cli\.mjs\s+watch/.test(command)) return "tsx watch dev server";
+  if (/next(-server)?\b.*\bdev\b/.test(command) || /next dev/.test(command)) return "next dev server";
+  if (/nodemon/.test(command)) return "nodemon";
+  if (/webpack|vite/.test(command)) return "bundler dev server";
+  if (/jefrichat-mcp/.test(command)) return "jefri connector";
+  const bin = command.split(/\s+/)[1] ?? command.split(/\s+/)[0] ?? command;
+  return bin.split("/").pop() || "process";
+}
+function fdAdvice(hogs, opts) {
+  if (!hogs.length) return null;
+  const total = hogs.reduce((n, h) => n + h.fds, 0);
+  const byLabel = /* @__PURE__ */ new Map();
+  for (const h of hogs) {
+    const cur = byLabel.get(h.label) ?? { count: 0, fds: 0 };
+    byLabel.set(h.label, { count: cur.count + 1, fds: cur.fds + h.fds });
+  }
+  const worst = [...byLabel.entries()].sort((a, b) => b[1].fds - a[1].fds)[0];
+  const [label, agg] = worst;
+  const manyDuplicates = agg.count >= 4;
+  const heavy = total > 2e4 || agg.fds > opts.softLimit * 4;
+  if (!manyDuplicates && !heavy) return null;
+  const plural = agg.count === 1 ? "" : "es";
+  return `${agg.count} "${label}" process${plural} are holding ~${agg.fds.toLocaleString()} open files. File watching (and eventually new connections) can fail with EMFILE while they run.`;
+}
+function probeFdHogs(limit = 40) {
+  if (process.platform === "win32") return [];
+  try {
+    const out = cp6.execSync("lsof -n -P 2>/dev/null | awk 'NR>1 {print $2}' | sort | uniq -c | sort -rn | head -" + limit, {
+      encoding: "utf8",
+      timeout: 8e3,
+      maxBuffer: 8 * 1024 * 1024
+    });
+    const hogs = [];
+    for (const line of out.split("\n")) {
+      const m = /^\s*(\d+)\s+(\d+)\s*$/.exec(line);
+      if (!m) continue;
+      const fds = Number(m[1]);
+      const pid = Number(m[2]);
+      if (fds < 500) continue;
+      let command = "";
+      try {
+        command = cp6.execSync(`ps -p ${pid} -o command=`, { encoding: "utf8", timeout: 2e3 }).trim();
+      } catch {
+        continue;
+      }
+      if (!command) continue;
+      hogs.push({ pid, fds, label: labelFor(command) });
+    }
+    return hogs;
+  } catch {
+    return [];
+  }
+}
+function softFdLimit() {
+  try {
+    const n = Number(cp6.execSync("ulimit -n", { encoding: "utf8", shell: "/bin/sh", timeout: 2e3 }).trim());
+    return Number.isFinite(n) && n > 0 ? n : 256;
+  } catch {
+    return 256;
+  }
+}
+
+// src/setup.ts
+init_which();
+import cp7 from "node:child_process";
+import readline from "node:readline";
+var LINUX_PKG = { "terminal-notifier": "" };
+function resolveInstall(tool, platform, has = isOnPath) {
+  if (has(tool)) return { kind: "present", command: "" };
+  if (platform === "darwin") {
+    return has("brew") ? { kind: "brew", command: `brew install ${tool}` } : { kind: "brew-missing", command: `install Homebrew first (https://brew.sh), then: brew install ${tool}` };
+  }
+  if (LINUX_PKG[tool] === "") {
+    return { kind: "windows", command: `${tool} is macOS-only \u2014 notifications on this platform are informational` };
+  }
+  if (platform === "win32") {
+    return { kind: "windows", command: `${tool} has no native Windows build \u2014 use WSL, or skip it` };
+  }
+  const mgr = ["apt-get", "apt", "dnf", "yum", "pacman", "zypper", "apk"].find(has);
+  const command = mgr === "pacman" ? `sudo pacman -S ${tool}` : mgr === "apk" ? `sudo apk add ${tool}` : mgr ? `sudo ${mgr} install ${tool}` : `install ${tool} 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 ensureToolInteractive(opts) {
+  const out = opts.out ?? process.stderr;
+  const plan = resolveInstall(opts.tool, process.platform);
+  if (plan.kind === "present") return true;
+  out.write(`
+\u{1F427} ${opts.why}
+`);
+  if (plan.kind !== "brew") {
+    out.write(`   ${plan.command}
+`);
+    if (opts.thenWhat) out.write(`   ${opts.thenWhat}
+`);
+    return false;
+  }
+  const yes = await promptYesNoDefaultYes(`   Install ${opts.tool} now with Homebrew? (no password, no sudo) [Y/n] `);
+  if (!yes) {
+    out.write(`   No problem \u2014 any time:  ${plan.command}
+`);
+    return false;
+  }
+  out.write(`   Installing ${opts.tool}\u2026
+`);
+  try {
+    cp7.execFileSync("brew", ["install", opts.tool], { stdio: "inherit" });
+  } catch {
+    out.write(`   \u26A0\uFE0F  '${plan.command}' didn't finish \u2014 run it yourself, then try again.
+`);
+    return false;
+  }
+  if (isOnPath(opts.tool)) {
+    out.write(`   \u2705 ${opts.tool} installed.
+`);
+    return true;
+  }
+  out.write(`   \u26A0\uFE0F  ${opts.tool} isn't on PATH yet \u2014 open a new terminal and re-run.
+`);
+  return false;
+}
+var WHY = {
+  "terminal-notifier": 'Clicking a Jefri notification can open a reply box, so you answer without\n   going through your agent. macOS needs "terminal-notifier" for that \u2014 without\n   it the banner still appears, but clicking it does nothing.',
+  tmux: 'Autonomous "session" mode types incoming messages straight into your LIVE\n   agent window so you can watch it work, and gives the reply popup somewhere\n   nicer to open. Both need "tmux", a small standard terminal tool.'
+};
+
+// src/doctor.ts
+init_which();
 init_popup();
 import fs10 from "node:fs";
 var T = !!process.stdout.isTTY;
@@ -42173,7 +42433,7 @@ function mask(t) {
 }
 function hasCli(cmd) {
   try {
-    const r = cp6.spawnSync(cmd, ["--version"], {
+    const r = cp8.spawnSync(cmd, ["--version"], {
       encoding: "utf8",
       timeout: 5e3,
       shell: process.platform === "win32"
@@ -42267,6 +42527,18 @@ async function runDoctor() {
     const runMode2 = auto.mode === "session" ? auto.sessionReady ? "session (types into your live jefri-managed tmux session)" : "session (\u26A0\uFE0F not a jefri-managed tmux session \u2014 falls back to headless; launch via `jefrichat-mcp run <agent>`)" : auto.mode === "interval" ? `interval (batches every ${auto.intervalMinutes}m)` : "headless (one-shot per message)";
     info(`Autonomous mode is ON \u2014 ${runMode2}, brain "${auto.brain}" in ${auto.workdir} (jefri_autonomous to change)`);
   }
+  try {
+    const hogs = probeFdHogs();
+    const advice = fdAdvice(hogs, { softLimit: softFdLimit() });
+    if (advice) {
+      const worst = hogs.sort((a, b) => b.fds - a.fds)[0];
+      warn(
+        advice,
+        `biggest: pid ${worst.pid} (${worst.fds.toLocaleString()} files). List them with: lsof -n -P | awk '{print $2}' | sort | uniq -c | sort -rn | head`
+      );
+    }
+  } catch {
+  }
   console.log("");
   console.log(
     `  ${C.b}\u{1F4EC} ${panelInvocation(hasCli)}${C.x}  ${C.d}\u2014 read your messages and reply WITHOUT going through your agent${C.x}`
@@ -42280,6 +42552,22 @@ async function runDoctor() {
     if (fs10.existsSync(app))
       console.log(`     ${C.d}no terminal? open "Jefri Chat" from Spotlight (or drag ${app} to your Dock)${C.x}`);
   }
+  if (process.stdin.isTTY) {
+    if (macNeedsTerminalNotifier && getPrefs().enabled) {
+      await ensureToolInteractive({
+        tool: "terminal-notifier",
+        why: WHY["terminal-notifier"],
+        thenWhat: `Then re-run:  ${hasCli("jefri") ? "jefri" : "jefrichat-mcp"} doctor`
+      });
+    }
+    if (auto.enabled && auto.mode === "session" && !isOnPath("tmux")) {
+      await ensureToolInteractive({
+        tool: "tmux",
+        why: WHY.tmux,
+        thenWhat: `Then launch with:  JEFRI_EXPERIMENTAL_SESSION=1 ${hasCli("jefri") ? "jefri" : "jefrichat-mcp"} run <agent>`
+      });
+    }
+  }
   console.log("");
   if (problems === 0 && warnings === 0) {
     console.log(`${C.g}${C.b}All good \u2014 you're ready to chat.${C.x}
@@ -42337,7 +42625,12 @@ function ensureClient() {
   if (!clientPromise) {
     clientPromise = (async () => {
       const known = TOKEN ?? readTokenCache()[cacheKey];
-      const clientInfo = { name: "jefrichat-mcp", version: connectorVersion() };
+      const clientInfo = {
+        name: "jefrichat-mcp",
+        version: connectorVersion(),
+        cwd: process.cwd(),
+        machine: os7.hostname()
+      };
       const provision = () => JefriClient.connect({
         server: SERVER,
         username: USERNAME,
@@ -42410,6 +42703,8 @@ function ensureClient() {
           owner: c2.identity?.owner,
           server: SERVER,
           workdir: getAuto().workdir,
+          cwd: process.cwd(),
+          machine: os7.hostname(),
           getHost: () => detectedHost,
           isOnline: () => c2.online,
           isAutonomous: () => getAuto().enabled,
@@ -42418,6 +42713,31 @@ function ensureClient() {
             return { label: b.resolved, ready: b.ready };
           },
           sendText: sendAs,
+          // Read a conversation from the HUB, over the socket this process
+          // already holds. The panel's own inbox only has what arrived while
+          // this connector was running, so a freshly-started UI shows nothing
+          // for a conversation that has been going for weeks — which reads as
+          // broken rather than as empty.
+          fetchHistory: async ({ with: other, groupId, limit }) => {
+            const convId = groupId ? groupConversationId(groupId) : dmConversationId(self, other);
+            const p = waitFor(c2, "history", (e) => e.conversationId === convId);
+            c2.history(convId);
+            const res = await p;
+            const raw = (res?.messages ?? []).slice(-limit);
+            return raw.map((m) => ({
+              id: String(m.id ?? ""),
+              // Raw username for routing, sanitized copy for display — the same
+              // split the panel makes, for the same reason: a name can carry a
+              // bidi override that would reorder the line around it.
+              from: String(m.senderUsername ?? ""),
+              fromDisplay: sanitizeForDisplay(String(m.senderUsername ?? "")),
+              text: m.kind === "file" ? `\u{1F4CE} ${m.fileName ?? "file"}` : String(m.content ?? ""),
+              at: String(m.createdAt ?? ""),
+              mine: String(m.senderUsername ?? "") === self,
+              kind: m.kind === "file" ? "file" : "text",
+              fileName: m.fileName ?? null
+            }));
+          },
           handleWithBrain: async (m) => {
             const text5 = await runOnceForMessage({
               content: m.text,
@@ -42601,6 +42921,20 @@ async function main() {
   };
   process.stdin.once("end", shutdownOnHostClose);
   process.stdin.once("close", shutdownOnHostClose);
+  process.on("uncaughtException", (err) => {
+    const code3 = err?.code;
+    if (code3 === "EMFILE" || code3 === "ENFILE" || code3 === "EAGAIN") {
+      log(
+        `WARNING: ${code3} \u2014 this machine is out of file descriptors. Something else is holding them (check for abandoned \`tsx watch\`/dev-server processes). Continuing in degraded mode; file watching may not work until pressure drops.`
+      );
+      return;
+    }
+    log("fatal (uncaught):", err?.stack ?? err);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (reason) => {
+    log("unhandled rejection:", reason?.stack ?? reason);
+  });
   void checkForUpdate().then((u) => {
     if (u?.outdated)
       note(

package/package.json

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