rogerthat 1.24.3 → 1.24.5

package/dist/cli.js

@@ -10,10 +10,41 @@ import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { parseArgs } from "node:util";
-import { runListenHere } from "./listen-here.js";
-import { runReceiveRecipe } from "./receive-recipe.js";
+// NOTE: `parseArgs` (node:util), `./listen-here.js` and `./receive-recipe.js`
+// are imported DYNAMICALLY inside main(), AFTER requireModernNode(). They (and
+// listen-here's own `node:util` import) hard-fail at module-load time on Node
+// < 18.3 with a cryptic `SyntaxError: 'node:util' does not provide an export
+// 'parseArgs'`. Loading them statically would crash before our friendly version
+// check could run. Keep the top of this file dependent only on Node-16-safe
+// builtins so the guard below is what the user actually sees.
 const __dirname = dirname(fileURLToPath(import.meta.url));
+/** Hard-require Node >= 18.3 (parseArgs landed there; see package.json engines).
+ * Prints a clear message instead of the cryptic parseArgs SyntaxError. */
+function requireModernNode() {
+    const [maj = 0, min = 0] = process.versions.node.split(".").map((n) => Number(n));
+    if (maj > 18 || (maj === 18 && min >= 3))
+        return;
+    console.error(`rogerthat requires Node >= 18.3 — found v${process.versions.node}.\n` +
+        `Upgrade Node (e.g. \`nvm install 20 && nvm use 20\`, or https://nodejs.org) and retry.`);
+    process.exit(1);
+}
+// Load .env (no dependency on dotenv). Tries repo-root .env relative to this file.
+(function loadDotEnv() {
+    // dist/cli.js -> repo root; src/cli.ts -> repo root (one up from src)
+    const candidates = [join(__dirname, "..", ".env"), join(__dirname, "..", "..", ".env")];
+    for (const path of candidates) {
+        if (!existsSync(path))
+            continue;
+        const content = readFileSync(path, "utf-8");
+        for (const line of content.split("\n")) {
+            const m = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+            if (m && !process.env[m[1]]) {
+                process.env[m[1]] = m[2].replace(/^["']|["']$/g, "");
+            }
+        }
+        break;
+    }
+})();
 let PKG_VERSION = "?";
 try {
     PKG_VERSION = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf8")).version;
@@ -63,17 +94,24 @@ function isLocalHost(host) {
     return host === "127.0.0.1" || host === "localhost" || host === "::1";
 }
 async function main() {
+    // Friendly Node-version gate BEFORE any module that imports node:util's
+    // parseArgs is loaded (this file, listen-here, receive-recipe all do).
+    requireModernNode();
     // Subcommand dispatch: anything before flags. Detect by argv[2] being a
-    // non-flag word.
+    // non-flag word. Dynamic import so listen-here/receive-recipe (and their
+    // parseArgs dependency) only load after the version gate above.
     const first = process.argv[2];
     if (first === "listen-here") {
+        const { runListenHere } = await import("./listen-here.js");
         const code = await runListenHere(process.argv.slice(3));
         process.exit(code);
     }
     if (first === "receive-recipe") {
+        const { runReceiveRecipe } = await import("./receive-recipe.js");
         const code = runReceiveRecipe(process.argv.slice(3));
         process.exit(code);
     }
+    const { parseArgs } = await import("node:util");
     let parsed;
     try {
         parsed = parseArgs({

package/dist/listen-here.js

@@ -24,14 +24,20 @@ import { parseArgs } from "node:util";
 const HELP = `rogerthat listen-here — open an SSE receiver for a channel
 
 usage:
+  rogerthat listen-here --channel <id> --token <t> --identity-key <k> [options]
   rogerthat listen-here --channel <id> --token <t> --session <sid> [options]
 
 required:
   --channel <id>      channel id (returned by /join or create_channel)
   --token <t>         channel bearer token
-  --session <sid>     X-Session-Id from /join (the calling agent's session)
+  and ONE of:
+  --identity-key <k>  auto-join the channel with this identity_key to obtain a
+                      session (recommended — makes this command self-contained)
+  --session <sid>     reuse an X-Session-Id you already got from /join
 
 options:
+  --owner-password <p>  passed to the auto-join so the session is marked
+                        human-authorized (only meaningful with --identity-key)
   --origin <url>      RogerThat origin (default: https://rogerthat.chat)
   --since <msg_id>    resume from a known message id (skips per-session cursor)
   --on-message <cmd>  shell command to run for each delivered message; env vars
@@ -102,6 +108,8 @@ function parseFlags(argv) {
                 channel: { type: "string" },
                 token: { type: "string" },
                 session: { type: "string" },
+                "identity-key": { type: "string" },
+                "owner-password": { type: "string" },
                 origin: { type: "string" },
                 since: { type: "string" },
                 "on-message": { type: "string" },
@@ -123,8 +131,13 @@ function parseFlags(argv) {
     const channel = parsed.values.channel;
     const token = parsed.values.token;
     const session = parsed.values.session;
-    if (!channel || !token || !session) {
-        return { error: "missing required flag(s): --channel, --token, --session" };
+    const identityKey = parsed.values["identity-key"];
+    if (!channel || !token) {
+        return { error: "missing required flag(s): --channel, --token" };
+    }
+    // Either an explicit --session, or --identity-key to auto-join for one.
+    if (!session && !identityKey) {
+        return { error: "provide --session <sid> OR --identity-key <key> (auto-joins to get a session)" };
     }
     let since;
     if (parsed.values.since !== undefined) {
@@ -151,7 +164,9 @@ function parseFlags(argv) {
     return {
         channel,
         token,
-        session,
+        session: session ?? "",
+        identityKey,
+        ownerPassword: parsed.values["owner-password"],
         origin: parsed.values.origin ?? "https://rogerthat.chat",
         since,
         onMessage: parsed.values["on-message"],
@@ -284,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
@@ -389,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.
@@ -428,6 +472,55 @@ async function runOneConnection(args, sinceCursor, abortSignal) {
     }
     return { lastId, reason: "ended" };
 }
+/** Auto-join the channel with an identity_key to obtain a session_id, so the
+ *  receiver command can be a single self-contained line (no separate /join,
+ *  no `<SID>` placeholder). Uses node:http/https directly (Node-16-safe, same
+ *  as the SSE path). Returns the session_id or throws with a clear message. */
+function joinForSession(args) {
+    const url = new URL(`${args.origin.replace(/\/$/, "")}/api/channels/${args.channel}/join`);
+    const payload = JSON.stringify({
+        identity_key: args.identityKey,
+        ...(args.ownerPassword ? { owner_password: args.ownerPassword } : {}),
+    });
+    return new Promise((resolve, reject) => {
+        const reqFn = url.protocol === "https:" ? httpsRequest : httpRequest;
+        const req = reqFn({
+            method: "POST",
+            host: url.hostname,
+            port: url.port ? Number(url.port) : url.protocol === "https:" ? 443 : 80,
+            path: url.pathname + url.search,
+            headers: {
+                authorization: `Bearer ${args.token}`,
+                "content-type": "application/json",
+                "content-length": Buffer.byteLength(payload),
+                accept: "application/json",
+            },
+        }, (res) => {
+            let raw = "";
+            res.setEncoding("utf8");
+            res.on("data", (d) => (raw += d));
+            res.on("end", () => {
+                const status = res.statusCode ?? 0;
+                let body = {};
+                try {
+                    body = JSON.parse(raw);
+                }
+                catch {
+                    /* leave empty */
+                }
+                if (status >= 200 && status < 300 && body.session_id) {
+                    resolve(body.session_id);
+                }
+                else {
+                    reject(new Error(body.error || `join failed (HTTP ${status})`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(payload);
+        req.end();
+    });
+}
 export async function runListenHere(argv) {
     const parsed = parseFlags(argv);
     if ("help" in parsed) {
@@ -440,6 +533,19 @@ export async function runListenHere(argv) {
         return 2;
     }
     const args = parsed;
+    // No explicit --session? Auto-join with the identity_key to get one. This is
+    // what makes the receiver command self-contained (no <SID> to fill in).
+    if (!args.session) {
+        try {
+            args.session = await joinForSession(args);
+            if (!args.quiet)
+                console.error(`[listen-here] joined as session ${args.session.slice(0, 8)}…`);
+        }
+        catch (err) {
+            console.error(`[listen-here] auto-join failed: ${err.message}`);
+            return 1;
+        }
+    }
     const ac = new AbortController();
     const shutdown = (sig) => {
         if (!args.quiet)
@@ -470,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.3",
+  "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": [