rogerthat 1.24.3 → 1.24.4

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"],
@@ -428,6 +443,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 +504,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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rogerthat",
-  "version": "1.24.3",
+  "version": "1.24.4",
   "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": [