rogerthat 1.24.4 → 1.24.5

package/dist/listen-here.js

@@ -299,6 +299,30 @@ function formatLine(args, msg, savedPaths) {
     }
     return JSON.stringify(msg);
 }
+/** Append a raw status line to the inbox file (if --inbox is set). Used for the
+ *  relay's own health signals — connect / reconnect notices — so an agent's
+ *  Monitor (a `tail -F` of the inbox) sees a confirmation that the listener is
+ *  actually attached, instead of having to inspect `ps`/`ss` to tell a healthy
+ *  relay from a crashed one. Written even under --quiet: quiet silences stdout,
+ *  not the inbox's own heartbeat. The `⟲` marker keeps it greppable/skippable.
+ *  Best-effort — a failed append must never take the relay down. */
+function writeInboxStatus(args, text) {
+    if (!args.inbox)
+        return;
+    // Only in text mode. JSONL consumers parse each line (or the whole file) as
+    // JSON, so a bare `⟲ …` line would break them — they get message objects only.
+    if (args.format !== "text")
+        return;
+    try {
+        const dir = dirname(args.inbox);
+        if (dir && !existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(args.inbox, `⟲ [listen-here] ${text}\n`, { mode: 0o600 });
+    }
+    catch {
+        /* never let a health-line write kill the relay */
+    }
+}
 async function dispatch(args, msg) {
     // --min-priority filter: drop messages below the threshold entirely (no
     // inbox write, no hook spawn, no stdout). Missing priority counts as
@@ -404,6 +428,11 @@ async function runOneConnection(args, sinceCursor, abortSignal) {
         res.resume();
         return { lastId: sinceCursor, reason: "ended", statusError: status };
     }
+    // SSE handshake accepted → the relay is genuinely attached and will receive
+    // phone messages from here on. Announce it in the inbox so the agent's Monitor
+    // confirms "listening" without a manual selftest, and the operator's phone
+    // sees a peer come online. (See writeInboxStatus.)
+    writeInboxStatus(args, `● connected — listening on ${args.channel} as session ${(args.session ?? "").slice(0, 8)}…`);
     let lastId = sinceCursor;
     // If the operator aborts mid-stream, destroy() the response to unblock the
     // for-await on it.
@@ -547,12 +576,35 @@ export async function runListenHere(argv) {
             return 0;
         if (result.statusError !== undefined) {
             const status = result.statusError;
-            // 4xx (except 408/429) are permanent — bail rather than spin.
+            // 4xx (except 408/429) usually mean our SESSION is gone, not that our
+            // creds are bad: a server restart wipes in-memory sessions AND tombstones,
+            // so the stream returns 400 not_joined (or 410) for the session we held.
+            // Our join creds are durable, so the robust move is to mint a FRESH
+            // session and resume — a restart should be transparent, not fatal. Only
+            // bail if we have no identity to re-join with, or the re-join itself fails
+            // (that's a genuinely bad token / identity_key).
             if (status >= 400 && status < 500 && status !== 408 && status !== 429) {
-                console.error(`[listen-here] server returned ${status} — auth or session invalid; exiting`);
-                return 1;
+                // Re-join needs the identity_key (joinForSession auto-joins with it). If
+                // the listener was started with an explicit --session and no
+                // --identity-key, we have nothing to re-join with → bail as before.
+                if (!args.identityKey) {
+                    console.error(`[listen-here] server returned ${status} and no --identity-key to re-join with; exiting`);
+                    return 1;
+                }
+                try {
+                    args.session = await joinForSession(args);
+                    if (!args.quiet) {
+                        console.error(`[listen-here] re-joined after ${status} as session ${args.session.slice(0, 8)}… — resuming`);
+                    }
+                }
+                catch (err) {
+                    console.error(`[listen-here] re-join after ${status} failed (${err.message}); exiting`);
+                    return 1;
+                }
+            }
+            else {
+                console.error(`[listen-here] server returned ${status} — will retry`);
             }
-            console.error(`[listen-here] server returned ${status} — will retry`);
         }
         // Connection closed cleanly or with retryable error. Backoff then reconnect.
         if (ac.signal.aborted)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rogerthat",
-  "version": "1.24.4",
+  "version": "1.24.5",
   "mcpName": "io.github.opcastil11/rogerthat",
   "description": "Real-time chat for AI agents. A walkie-talkie hub that lets two or more agents — Claude Code, Cursor, Cline, Claude Desktop, Codex — on different machines send messages to each other over MCP or plain REST. Hosted at rogerthat.chat or self-hosted with `npx rogerthat`.",
   "keywords": [