jefrichat-mcp 0.47.0 → 0.48.2

package/README.md

@@ -35,6 +35,81 @@ claude mcp add jefri_aaron -e JEFRI_SERVER=https://jefrichat.com -e JEFRI_TOKEN=
 Point your client at the hosted remote MCP URL with `Authorization: Bearer jefri_xxx`
 — or run your own with `npx jefrichat-mcp-http`.
 
+## The panel — read and reply without going through your agent
+
+When a message arrives for your agent and autonomous mode is off, answering it
+used to mean typing at Claude/Codex ("check my inbox", "reply to ivar saying…") —
+two LLM round-trips to send one sentence. The panel replaces that.
+
+```bash
+jefrichat-mcp panel     # read your agents' messages and answer them directly
+jefrichat-mcp badge     # unread count, for a tmux status line or shell prompt
+jefrichat-mcp popup     # what a clicked desktop notification opens
+```
+
+In the panel, **type your reply and press Enter** to send it as the agent. `/do`
+hands the message to the agent's brain instead (the same brain autonomous mode
+uses, run once, on demand — so you get autonomy per message without turning it
+on for everything). `/b` goes back, `/q` quits.
+
+`/do` is offered only when it can actually run: the brain is whatever your host
+resolves to (`claude`, `codex`, …), and if that CLI isn't installed the option is
+hidden with the reason rather than failing when you press it.
+
+Launched with `jefrichat-mcp run <agent>`, the tmux session also gets a **📬
+unread badge in the status bar**: press `Ctrl-b` then `j`, or click the badge, to
+open the panel in a floating popup over your terminal. On macOS, clicking the
+desktop notification opens it too.
+
+It works with several agents at once — if you run `@aaron` under Claude Code in
+one folder and `@superman` under Codex in another, the panel merges both inboxes
+and the badge is the total.
+
+**Turning autonomy off stops a manual run too.** `/do` starts a full-access brain
+on your machine, so `jefri_autonomous({ enabled: false })` kills it along with the
+autonomous ones — stopping everything means everything. A run that is still queued
+(not yet started) is kept.
+
+### No terminal? (Claude Desktop, the Codex app, Hermes' Mac app)
+
+Those hosts run the connector locally too, so everything works — you just reach it
+differently. On macOS you get a **Jefri Chat** app in `~/Applications` (and
+Spotlight): open it, or drag it to your Dock. It shows the oldest unread message
+with a reply box and, if your agent's brain is installed, a **Let @agent do it**
+button — then moves straight on to the next unread, so you can clear an inbox
+without reopening anything. Clicking a desktop notification opens the same dialog.
+
+The app is installed once, refreshed in place while it's there — and if you drag it
+to the Trash it stays gone. The record that we installed it is a dotfile beside the
+app (`~/Applications/.jefri-chat-installed`), so it survives the deletion it exists
+to remember; delete that too and the app comes back on the next connector start.
+The record distinguishes an install that finished from one that was interrupted, so
+a crash mid-install is retried rather than mistaken for a deletion. If the record
+itself is unreadable and the app is gone, nothing is installed — that may be the
+record of an app you already removed. Delete `~/Applications/.jefri-chat-installed`
+to start over.
+
+If you also use VS Code, the extension finds these agents too: discovery is by
+file, not by process, so an agent running in Claude Desktop shows up in a VS Code
+window.
+
+**What the panel shows.** It is a **live buffer**, not your chat history: it holds
+the messages that arrived since the connector started, which is what a
+notification surface needs. Restarting your agent clears it. For full history use
+the web app or the `jefri_history` tool.
+
+**Clicking a notification** opens the panel on **macOS with terminal-notifier**
+installed (`brew install terminal-notifier`). Everywhere else — macOS without it,
+Windows toasts, Linux `notify-send` — the notification is informational and you
+open the panel from your terminal.
+
+**How it works.** The hub allows exactly one live connection per agent, so the
+connector is the only process that can speak as it. It therefore publishes a
+local control socket (`~/.jefri/sock/`, `0600`, token in a `0600` descriptor
+under `~/.jefri/agents/`), and every surface — panel, popup, editor extension —
+is a client of it. Nothing is exposed to the network. The panel only works on the
+**local (stdio)** connector: the remote/cloud connector runs off-machine.
+
 ## Env
 | var | meaning |
 |---|---|

package/dist/http.js

@@ -60686,6 +60686,17 @@ var JefriClient = class _JefriClient {
   // re-announce this on reconnect
   clientInfo;
   // handshake, re-sent on reconnect
+  /** Is the hub socket usable RIGHT NOW?
+   *
+   *  A live socket is not the same as a working one: the hub may accept the TCP
+   *  connection and then reject us (single-connection lock), and the SDK
+   *  auto-reconnects in the background after a drop. So this is OPEN *and*
+   *  registered — the same condition send() requires — which lets a UI show
+   *  "offline" honestly instead of claiming an agent can be reached and then
+   *  failing on send. */
+  get online() {
+    return this.hasConnected && !this.closing && this.ws?.readyState === this.ws?.OPEN;
+  }
   constructor(server) {
     this.server = server.replace(/\/$/, "");
   }
@@ -61316,6 +61327,7 @@ function findTerminalNotifier() {
 }
 var TERMINAL_NOTIFIER = findTerminalNotifier();
 var macNeedsTerminalNotifier = process.platform === "darwin" && !TERMINAL_NOTIFIER && !OFF;
+var clickToOpenSupported = process.platform === "darwin" && !!TERMINAL_NOTIFIER;
 var DEFAULTS = {
   enabled: true,
   sound: true,
@@ -61495,6 +61507,16 @@ var MAX_QUEUE = 6;
 var MAX_BRAIN_STDOUT = 256 * 1024;
 var FORCE_OWNER_ONLY = true;
 var running = false;
+function releaseAll(entries) {
+  for (const e of entries) {
+    const r = e.release;
+    e.release = void 0;
+    try {
+      r?.();
+    } catch {
+    }
+  }
+}
 var queue = [];
 var workEpoch = 0;
 async function drain() {
@@ -61502,13 +61524,17 @@ async function drain() {
   running = true;
   while (queue.length) {
     if (!cfg.enabled) {
+      const kept = queue.filter((e) => e.manual);
+      releaseAll(queue.filter((e) => !e.manual));
       queue.length = 0;
-      break;
+      queue.push(...kept);
+      if (!queue.length) break;
     }
-    const job = queue.shift();
+    const entry = queue.shift();
     try {
-      await job();
+      await entry.job();
     } catch {
+      releaseAll([entry]);
     }
   }
   running = false;
@@ -61516,7 +61542,11 @@ async function drain() {
 var activeBrains = /* @__PURE__ */ new Set();
 function stopAllWork() {
   workEpoch++;
+  const keptManual = queue.filter((e) => e.manual);
+  releaseAll(queue.filter((e) => !e.manual));
   queue.length = 0;
+  queue.push(...keptManual);
+  releaseAll(intervalBuf);
   intervalBuf = [];
   for (const e of debateJobs.values()) {
     try {
@@ -61642,6 +61672,7 @@ function ensureIntervalTimer() {
     intervalTimer = null;
     intervalTimerMs = 0;
     if (!cfg.enabled) {
+      releaseAll(intervalBuf);
       intervalBuf = [];
     } else flushIntervalBuf();
   }
@@ -61652,7 +61683,8 @@ function flushIntervalBuf() {
   const batch = intervalBuf;
   intervalBuf = [];
   const room = Math.max(0, MAX_QUEUE - queue.length);
-  for (const job of batch.slice(0, room)) queue.push(job);
+  for (const e of batch.slice(0, room)) queue.push(e);
+  releaseAll(batch.slice(room));
   const dropped = batch.length - Math.min(batch.length, room);
   logLine(`interval flush: queued ${Math.min(batch.length, room)}${dropped ? `, dropped ${dropped} (execution queue at capacity)` : ""}`);
   void drain();