@joystack/cli 0.1.55 → 0.1.56

package/lib/relay/connection.mjs

@@ -1,7 +1,6 @@
-// The hub's credential for the agent: each running dev server writes its port
+// The relay's credential for the agent: each running dev server writes its port
 // and a bearer token to .joystack/relay/.connection-<port>, owner-only, so
-// only a process that can read the game folder can publish or tail as the
-// agent. `joystack relay` reads every file there and speaks to each server.
+// only a process that can read the game folder can reply as the agent. `joystack relay` reads every file there and speaks to each server.
 import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { stateDir } from '../legacy-names.mjs';

package/lib/relay/conversation.mjs

@@ -1,21 +1,22 @@
-// The hub's own listener for the laptop conversation: a `note.sent` event
-// (the note in shared/ui/note/, once the person pressed Send) becomes files
-// the agent can open under .joystack/relay/ and a message in the Claude Code
-// session that started this dev server, through that session's inbox socket
-// (agent-session.mjs). Installed only when a session started the server; a
-// server from a plain terminal has no such listener, and the maker's dev
-// server has none either (its conversation is the maker page's).
+// The laptop conversation: a note the person sent (shared/ui/note/, once
+// they pressed Send) becomes files the agent can open under .joystack/relay/
+// and a message in the Claude Code session that started this dev server,
+// through that session's inbox socket (agent-session.mjs). Made only when a
+// session started the server; a server from a plain terminal has none, and
+// the maker's dev server has none either (its conversation is the maker
+// page's).
 //
-// Reaching the agent starts paid work, so only a note the person sent from
-// the creator's own browser wakes it: the hub stamps `from.creator`, and a
-// page a phone on the wifi or a --share tester loaded is never the creator's.
+// Reaching the agent starts paid work, so only a note the creator's own
+// browser sent reaches here: the relay's route refuses any other page
+// (relay.mjs), and a page a phone on the wifi or a --share tester
+// loaded is never the creator's.
 import { randomBytes } from 'node:crypto';
 import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { postToSession, sessionAlive } from '../agent-session.mjs';
 import { relayDir } from './connection.mjs';
 
-// A page can publish in a loop. The agent is woken at most this often: a note
+// A page can send notes in a loop. The agent is woken at most this often: a note
 // sent sooner waits its turn, and once this many are waiting, the rest are
 // filed without waking it (a burst that size is a script, not someone typing).
 export const WAKE_MIN_INTERVAL_MS = 1000;
@@ -41,12 +42,12 @@ export function shellWord(text) {
 // so no line of it can read as one the server wrote (a second header, a
 // different reply command).
 const LINE_BREAK_RE = /\r\n?|[\u0085\u2028\u2029]/g;
-const asLines = (text) => String(text).replace(LINE_BREAK_RE, '\n').replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, '').split('\n');
+const asLines = (text) => String(text).replace(LINE_BREAK_RE, '\n').replace(/[\u0000-\u0008\u000b-\u001f\u007f-\u0084\u0086-\u009f]/g, '').split('\n');
 const indented = (text) => asLines(text).map((l) => `  ${l}`).join('\n');
 // A label is one line: JSON.stringify escapes \n and \r but not the Unicode
 // separators, so they are made spaces first.
 const oneLine = (text) => asLines(text).join(' ');
-// The kind of thing attached is an event name (relay.mjs NAME_RE) or nothing.
+// The kind of thing attached is a relay name (`<owner>.<what>`) or nothing.
 const KIND_RE = /^[a-z0-9][a-z0-9-]*(\.[a-z0-9][a-z0-9-]*)+$/;
 
 // The message that wakes the agent. Everything the server writes comes
@@ -58,8 +59,7 @@ export function agentMessage({ kind, label, words, text, file, image, id, projec
   if (words) lines.push(indented(words));
   lines.push(`Data: ${file}`);
   if (image) lines.push(`Picture of what they see: ${image}`);
-  const reply = JSON.stringify({ to: id, text: '<what you did>' });
-  lines.push(`Answer where they asked, in one or two sentences: node ${shellWord(cliBin)} relay publish --dir ${shellWord(projectDir)} agent.replied ${shellWord(reply)}`);
+  lines.push(`Answer where they asked, in one or two sentences: node ${shellWord(cliBin)} relay reply --dir ${shellWord(projectDir)} ${id} '<what you did>'`);
   lines.push('', ...asLines(String(text).trim()).map((line) => `> ${line}`));
   return lines.join('\n');
 }

package/lib/relay/engine.mjs

@@ -0,0 +1,15 @@
+// The folder of the engine's relay the dev server loads its pure files from:
+// the game's installed engine, or this CLI's own repository when it runs
+// from inside it. Null when that engine has no relay with `files` in it.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function relayFiles(sharedDir, files) {
+  // The repository's own relay only from a checkout of it: an installed CLI
+  // sits in node_modules, where the same path names a package called
+  // `shared`.
+  const repo = join(import.meta.dirname, '../../../..');
+  const fromRepo = existsSync(join(repo, 'packages', 'cli', 'package.json')) ? join(repo, 'shared', 'ui', 'relay') : null;
+  const candidates = [sharedDir && join(sharedDir, 'ui', 'relay'), fromRepo];
+  return candidates.find((dir) => dir && files.every((f) => existsSync(join(dir, f)))) ?? null;
+}

package/lib/relay/http.mjs

@@ -0,0 +1,57 @@
+// The relay's HTTP pieces on the dev server: answers, a bounded body, and
+// the agent's bearer token.
+import { timingSafeEqual } from 'node:crypto';
+
+// What one post may weigh: a pick carries its picture.
+export const MAX_BYTES = 8 * 1024 * 1024;
+const LOOPBACK = new Set(['127.0.0.1', '::1', '::ffff:127.0.0.1']);
+
+export const json = (res, status, body, extra = {}) => {
+  const buf = Buffer.from(JSON.stringify(body));
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': buf.length, 'Cache-Control': 'no-store', ...extra });
+  res.end(buf);
+};
+export const text = (res, status, body, extra = {}) => {
+  res.writeHead(status, { 'Content-Type': 'text/plain', ...extra });
+  res.end(body);
+};
+// The agent's credential: a bearer token from a process on this machine,
+// never a browser (which always sends Origin on a cross-origin request and
+// cannot set this header from a page the server did not serve). 'agent'
+// when it is the server's token, 'refused' when a bearer was offered and is
+// not, null when none was offered.
+export function bearer(req, token) {
+  const header = String(req.headers.authorization ?? '');
+  if (!header.startsWith('Bearer ')) return null;
+  const supplied = Buffer.from(header.slice(7));
+  const expected = Buffer.from(token);
+  const ok = LOOPBACK.has(req.socket.remoteAddress) && !req.headers.origin
+    && supplied.length === expected.length && timingSafeEqual(supplied, expected);
+  return ok ? 'agent' : 'refused';
+}
+
+export function readBody(req, res, maxBytes) {
+  return new Promise((resolve) => {
+    const chunks = [];
+    let size = 0;
+    let overflowed = false;
+    req.on('data', (chunk) => {
+      if (overflowed) return; // draining the rest so the client can read the 413
+      size += chunk.length;
+      if (size > maxBytes) {
+        overflowed = true;
+        chunks.length = 0;
+        text(res, 413, `message too large (max ${maxBytes} bytes)`, { Connection: 'close' });
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => resolve(overflowed ? null : Buffer.concat(chunks).toString('utf8')));
+    // A client that goes before the body ends is answered by nobody; the
+    // promise still settles, so nothing waits on it for good.
+    req.on('close', () => { if (!req.complete) resolve(null); });
+    req.on('error', () => resolve(null));
+  });
+}
+export const parse = (raw) => { try { return JSON.parse(raw); } catch { return undefined; } };
+