rogerthat 1.24.4 → 1.24.6

package/dist/listen-here.js

@@ -67,6 +67,11 @@ options:
                       Filtered messages do NOT write to --inbox, fire --on-message,
                       or print to stdout. Use for park-style channels: stay
                       wake-able only on real signals, let chatter accumulate silently.
+  --heartbeat <secs>  write a "♥ alive" line to --inbox every <secs> seconds so an
+                      operator/Monitor can confirm the relay is still up WITHOUT
+                      consuming a real message. Off by default. Needs --inbox and
+                      --format text. (Non-destructive alternative: poll /roster —
+                      your callsign present = listener alive.)
   --quiet             suppress the default stdout dump of each message
 
 if neither --on-message nor --inbox is given, messages print to stdout (one
@@ -116,6 +121,7 @@ function parseFlags(argv) {
                 inbox: { type: "string" },
                 format: { type: "string" },
                 "min-priority": { type: "string" },
+                heartbeat: { type: "string" },
                 quiet: { type: "boolean" },
                 help: { type: "boolean", short: "h" },
             },
@@ -161,6 +167,13 @@ function parseFlags(argv) {
         }
         minPriority = v;
     }
+    let heartbeat;
+    if (parsed.values.heartbeat !== undefined) {
+        const n = Number(parsed.values.heartbeat);
+        if (!Number.isFinite(n) || n <= 0)
+            return { error: "--heartbeat must be a positive number of seconds" };
+        heartbeat = n;
+    }
     return {
         channel,
         token,
@@ -174,6 +187,7 @@ function parseFlags(argv) {
         format,
         quiet: parsed.values.quiet === true,
         minPriority,
+        heartbeat,
     };
 }
 /** Sanitize a filename for use on disk: strip path separators, NUL, leading
@@ -299,6 +313,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 +442,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.
@@ -525,6 +568,17 @@ export async function runListenHere(argv) {
     };
     process.once("SIGINT", () => shutdown("SIGINT"));
     process.once("SIGTERM", () => shutdown("SIGTERM"));
+    // Opt-in liveness heartbeat: write a `♥ alive` line to the inbox every N
+    // seconds so an operator/Monitor can confirm the relay is up WITHOUT consuming
+    // a real message. .unref() so it never keeps the process alive on its own;
+    // cleared on shutdown via the abort signal.
+    if (args.heartbeat) {
+        const hb = setInterval(() => {
+            writeInboxStatus(args, `♥ alive — session ${args.session.slice(0, 8)}… (still listening)`);
+        }, args.heartbeat * 1000);
+        hb.unref?.();
+        ac.signal.addEventListener("abort", () => clearInterval(hb));
+    }
     if (!args.quiet) {
         console.error(`[listen-here] connecting to ${args.origin}/api/channels/${args.channel}/stream`);
     }
@@ -547,12 +601,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.6",
   "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": [