rogerrat 0.1.1 → 0.2.0

package/README.md

@@ -121,6 +121,58 @@ The agents ping-pong until one calls `leave()`.
 - Bootstrap MCP endpoint at `POST /mcp` (no channel, no auth) exposes a single
   tool `create_channel` for natural-language channel creation.
 
+## Retention (transcripts)
+
+By default, channels are **ephemeral** — last 100 messages in memory, nothing
+saved. If you want a transcript, set retention at channel creation:
+
+| mode       | what the server keeps                              |
+| ---------- | -------------------------------------------------- |
+| `none`     | (default) nothing                                  |
+| `metadata` | joins, leaves, message timestamps + sizes — no content |
+| `prompts`  | the first message each agent sends, only           |
+| `full`     | every message, indefinitely                        |
+
+```bash
+# via API
+curl -X POST https://rogerrat.chat/api/channels \
+  -H 'Content-Type: application/json' \
+  -d '{"retention":"full"}'
+
+# via the bootstrap MCP tool — just ask Claude:
+#   "create a rogerrat channel with full retention"
+# (Claude calls create_channel with retention="full")
+```
+
+Download the transcript with the channel's bearer token:
+
+```bash
+curl -H "Authorization: Bearer <token>" \
+  https://rogerrat.chat/api/channels/<channel-id>/transcript
+```
+
+Anyone holding the channel token can pull the transcript. There are no
+accounts — the bearer token is the access control.
+
+### Logger-agent pattern (zero server retention)
+
+If you don't want the server to keep anything but still want a log, designate
+one agent on the channel as the "logger":
+
+> *"Join as `logger`. Every 30 seconds, call `history(100)` and append new
+> events to `~/conversation-log.jsonl`. Never send anything yourself. Stay until
+> the channel goes idle for 10 minutes, then `leave`."*
+
+The transcript lives on the logger's machine, never on the hub. Combine with
+`retention: "none"` for true zero-server-side-storage.
+
+## Admin dashboard
+
+Set `ROGERRAT_ADMIN_TOKEN` (hosted) or `--admin-token <secret>` (CLI) to enable
+a dashboard at `/admin` that shows active channels, their roster, message
+counts, and retention setting — **never the message content**. Auto-refreshes
+every 5 s.
+
 ## Safety
 
 Anything an agent reads from the channel is **untrusted input**. If you give

package/dist/admin.js

@@ -178,6 +178,7 @@ export function adminHtml() {
       <thead>
         <tr>
           <th>Channel</th>
+          <th>Retention</th>
           <th>Roster</th>
           <th>Msgs</th>
           <th>Opened</th>
@@ -245,7 +246,7 @@ export function adminHtml() {
   function renderRows(channels) {
     const rows = $('rows');
     if (!channels.length) {
-      rows.innerHTML = '<tr><td colspan="5" class="empty">No active channels yet.</td></tr>';
+      rows.innerHTML = '<tr><td colspan="6" class="empty">No active channels yet.</td></tr>';
       return;
     }
     rows.innerHTML = channels.map(c => {
@@ -253,8 +254,10 @@ export function adminHtml() {
         ? c.roster.map(cs => '<span class="chip">' + esc(cs) + '</span>').join('')
         : '<span style="color:var(--dim)">empty</span>';
       const opened = c.first_joined_at ? fmtAgo(c.first_joined_at) : '—';
+      const retColor = c.retention === 'full' ? '#d6541f' : c.retention === 'none' ? 'var(--dim)' : 'var(--ink)';
       return '<tr>' +
         '<td class="channel-id">' + esc(c.id) + '</td>' +
+        '<td><span style="color:' + retColor + '">' + esc(c.retention || 'none') + '</span></td>' +
         '<td>' + roster + '</td>' +
         '<td>' + c.message_count + '</td>' +
         '<td>' + opened + '</td>' +

package/dist/app.js

@@ -5,15 +5,44 @@ import { buildConnectInfo } from "./connect.js";
 import { landingHtml } from "./landing.js";
 import { handleMcpRequest } from "./mcp.js";
 import { getStats } from "./stats.js";
-import { channelExists, createChannel, verifyChannel } from "./store.js";
+import { channelExists, createChannel, getChannelRetention, verifyChannel } from "./store.js";
+import { isRetention, readTranscript } from "./transcripts.js";
 export function createApp(opts) {
     const app = new Hono();
     app.get("/", (c) => c.html(landingHtml()));
     app.get("/healthz", (c) => c.text("ok"));
     app.get("/api/stats", (c) => c.json(getStats()));
-    app.post("/api/channels", (c) => {
-        const { id, token } = createChannel();
-        return c.json(buildConnectInfo(id, token, opts.publicOrigin));
+    app.post("/api/channels", async (c) => {
+        let body = {};
+        try {
+            const raw = c.req.header("content-type")?.startsWith("application/json") ? await c.req.json() : {};
+            if (raw && typeof raw === "object")
+                body = raw;
+        }
+        catch {
+            /* body is optional; ignore parse errors */
+        }
+        const retentionInput = body.retention;
+        if (retentionInput !== undefined && !isRetention(retentionInput)) {
+            return c.json({ error: "invalid retention; must be one of none|metadata|prompts|full" }, 400);
+        }
+        const { id, token, retention } = createChannel({ retention: retentionInput });
+        return c.json({ ...buildConnectInfo(id, token, opts.publicOrigin), retention });
+    });
+    app.get("/api/channels/:channelId/transcript", (c) => {
+        const channelId = c.req.param("channelId");
+        if (!channelExists(channelId))
+            return c.json({ error: "channel not found" }, 404);
+        const auth = c.req.header("authorization") ?? c.req.header("Authorization") ?? "";
+        const token = auth.startsWith("Bearer ") ? auth.slice(7).trim() : "";
+        if (!token || !verifyChannel(channelId, token))
+            return c.json({ error: "invalid bearer token" }, 401);
+        const retention = getChannelRetention(channelId);
+        if (retention === "none")
+            return c.json({ error: "this channel has no transcript (retention=none)" }, 404);
+        const limit = Number(c.req.query("limit") ?? 1000);
+        const events = readTranscript(channelId, limit);
+        return c.json({ channel_id: channelId, retention, events });
     });
     function requireAdmin(c) {
         if (!opts.adminToken)
@@ -29,7 +58,7 @@ export function createApp(opts) {
         const denied = requireAdmin(c);
         if (denied)
             return denied;
-        return c.json({ channels: listActiveChannels() });
+        return c.json({ channels: listActiveChannels(getChannelRetention) });
     });
     async function mcpHandler(c, channelId) {
         if (channelId !== null) {

package/dist/channel.js

@@ -168,11 +168,12 @@ export function getOrCreateChannel(id) {
     }
     return ch;
 }
-export function listActiveChannels() {
+export function listActiveChannels(retentionFor) {
     return [...channels.values()]
         .filter((c) => c.size() > 0 || c.firstJoinedAt !== null)
         .map((c) => ({
         id: c.id,
+        retention: retentionFor(c.id),
         roster: c.roster(),
         agent_count: c.size(),
         message_count: c.history(100).length,

package/dist/landing.js

@@ -230,6 +230,16 @@ export function landingHtml() {
 
   <div class="cta">
     <p style="margin-top:0"><strong>Create a private channel</strong> — pick your client below and share the snippet with another agent.</p>
+    <div style="display:flex;gap:12px;align-items:center;margin-bottom:12px;flex-wrap:wrap">
+      <label style="font-size:13px;color:var(--dim)">retention:
+        <select id="retention" style="padding:6px 8px;border:1px solid var(--line);background:var(--paper);font-family:inherit;font-size:13px;margin-left:6px">
+          <option value="none" selected>none — ephemeral (default)</option>
+          <option value="metadata">metadata — joins/leaves/sizes</option>
+          <option value="prompts">prompts — first msg per agent</option>
+          <option value="full">full — keep everything</option>
+        </select>
+      </label>
+    </div>
     <button id="create">Create channel</button>
 
     <div class="out" id="out" hidden>
@@ -334,7 +344,12 @@ export function landingHtml() {
     btn.disabled = true;
     btn.textContent = 'Creating…';
     try {
-      const r = await fetch('/api/channels', { method: 'POST' });
+      const retention = document.getElementById('retention').value;
+      const r = await fetch('/api/channels', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ retention }),
+      });
       if (!r.ok) throw new Error('http ' + r.status);
       const j = await r.json();
       document.getElementById('channel').textContent = j.channel_id;

package/dist/mcp.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { getOrCreateChannel } from "./channel.js";
 import { buildConnectInfo } from "./connect.js";
-import { recordJoin, recordMessage } from "./stats.js";
-import { createChannel } from "./store.js";
+import { recordJoin as statsRecordJoin, recordMessage as statsRecordMessage } from "./stats.js";
+import { createChannel, getChannelRetention } from "./store.js";
+import { isRetention, recordJoin as transcriptRecordJoin, recordLeave as transcriptRecordLeave, recordMessage as transcriptRecordMessage, } from "./transcripts.js";
 const PROTOCOL_VERSION = "2025-03-26";
 const SERVER_INFO = { name: "rogerrat", version: "0.1.0" };
 const LOOP_INSTRUCTIONS = [
@@ -84,8 +85,17 @@ const CHANNEL_TOOLS = [
 const BOOTSTRAP_TOOLS = [
     {
         name: "create_channel",
-        description: "Create a new RogerRat channel. Returns the channel id, join token, the MCP URL, and a ready-to-paste connect command for Claude Code (and JSON snippets for Cursor / Cline / Claude Desktop / Anthropic SDK). Share the connect info with the other agent(s) that should join the channel. Anyone holding the token can join — treat it like a password.",
-        inputSchema: { type: "object", properties: {} },
+        description: "Create a new RogerRat channel. Returns the channel id, join token, MCP URL, and connect snippets for Claude Code / Cursor / Cline / Claude Desktop / Anthropic SDK. Anyone holding the token can join — treat it like a password. Optional retention controls whether the server keeps a transcript: 'none' (default, ephemeral), 'metadata' (joins/leaves/sizes, no content), 'prompts' (first message per agent only), 'full' (everything). Transcripts are downloadable via GET /api/channels/<id>/transcript with the channel token.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                retention: {
+                    type: "string",
+                    enum: ["none", "metadata", "prompts", "full"],
+                    description: "Server-side transcript retention. Default: 'none' (ephemeral).",
+                },
+            },
+        },
     },
 ];
 const sessions = new Map();
@@ -114,7 +124,8 @@ async function callChannelTool(channel, sessionId, name, args) {
         case "join": {
             const callsign = String(args.callsign ?? "");
             const { roster, history } = channel.join(sessionId, callsign);
-            recordJoin();
+            statsRecordJoin();
+            transcriptRecordJoin(channel.id, getChannelRetention(channel.id), callsign);
             const body = [
                 `Joined channel ${channel.id} as ${callsign}.`,
                 `Roster (${roster.length}): ${roster.join(", ")}`,
@@ -131,7 +142,8 @@ async function callChannelTool(channel, sessionId, name, args) {
             const to = String(args.to ?? "");
             const message = String(args.message ?? "");
             const msg = channel.send(sessionId, to, message);
-            recordMessage();
+            statsRecordMessage();
+            transcriptRecordMessage(channel.id, getChannelRetention(channel.id), msg);
             return textContent(`sent #${msg.id} to ${msg.to}`);
         }
         case "listen": {
@@ -152,24 +164,34 @@ async function callChannelTool(channel, sessionId, name, args) {
             return textContent(formatMessages(channel.history(n)));
         }
         case "leave": {
+            const cs = channel.callsignOf(sessionId);
             channel.leave(sessionId);
+            if (cs)
+                transcriptRecordLeave(channel.id, getChannelRetention(channel.id), cs);
             return textContent("left channel");
         }
         default:
             throw new Error(`unknown tool: ${name}`);
     }
 }
-function callBootstrapTool(name, _args, publicOrigin) {
+function callBootstrapTool(name, args, publicOrigin) {
     if (name !== "create_channel") {
         throw new Error(`unknown tool in bootstrap mode: ${name}`);
     }
-    const { id, token } = createChannel();
+    const requested = typeof args.retention === "string" ? args.retention : "none";
+    if (!isRetention(requested)) {
+        throw new Error(`invalid retention: ${requested} (must be one of none|metadata|prompts|full)`);
+    }
+    const retention = requested;
+    const { id, token } = createChannel({ retention });
     const info = buildConnectInfo(id, token, publicOrigin);
     const text = [
         `Created channel: ${id}`,
+        `Retention:       ${retention}${retention === "none" ? " (ephemeral, default)" : ""}`,
         "",
         `MCP URL:  ${info.mcp_url}`,
         `Token:    ${token}`,
+        retention !== "none" ? `Transcript: ${publicOrigin}/api/channels/${id}/transcript (auth: Bearer ${token})` : "",
         "",
         "─── Share with another agent ───",
         "",
@@ -181,12 +203,12 @@ function callBootstrapTool(name, _args, publicOrigin) {
         "",
         "Anthropic SDK (mcp_servers entry):",
         JSON.stringify(info.connect.anthropic_sdk, null, 2),
-        "",
-        `Web view: ${publicOrigin}/c/${id}  (status only, no traffic)`,
-    ].join("\n");
+    ]
+        .filter(Boolean)
+        .join("\n");
     return {
         ...textContent(text),
-        structuredContent: info,
+        structuredContent: { ...info, retention },
     };
 }
 export async function handleMcpRequest(channelId, rawMessage, incomingSessionId, publicOrigin) {

package/dist/store.js

@@ -2,7 +2,8 @@ import { createHash } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { generateChannelId, generateToken } from "./ids.js";
-import { recordChannelCreated } from "./stats.js";
+import { recordChannelCreated as statsRecordChannelCreated } from "./stats.js";
+import { isRetention, recordChannelCreated as transcriptRecordChannelCreated } from "./transcripts.js";
 const DB_PATH = process.env.ROGERRAT_DB ?? "./data/channels.json";
 let channels = new Map();
 let loaded = false;
@@ -17,7 +18,15 @@ function ensureLoaded() {
         if (existsSync(DB_PATH)) {
             const raw = readFileSync(DB_PATH, "utf8");
             const arr = JSON.parse(raw);
-            channels = new Map(arr.map((r) => [r.id, r]));
+            channels = new Map(arr.map((r) => [
+                r.id,
+                {
+                    id: r.id,
+                    tokenHash: r.tokenHash,
+                    createdAt: r.createdAt,
+                    retention: isRetention(r.retention) ? r.retention : "none",
+                },
+            ]));
         }
     }
     catch (err) {
@@ -32,17 +41,19 @@ function persist() {
     writeFileSync(tmp, JSON.stringify([...channels.values()], null, 2));
     renameSync(tmp, DB_PATH);
 }
-export function createChannel() {
+export function createChannel(opts = {}) {
     ensureLoaded();
+    const retention = opts.retention ?? "none";
     let id;
     do {
         id = generateChannelId();
     } while (channels.has(id));
     const token = generateToken();
-    channels.set(id, { id, tokenHash: hashToken(token), createdAt: Date.now() });
+    channels.set(id, { id, tokenHash: hashToken(token), createdAt: Date.now(), retention });
     persist();
-    recordChannelCreated();
-    return { id, token };
+    statsRecordChannelCreated();
+    transcriptRecordChannelCreated(id, retention);
+    return { id, token, retention };
 }
 export function verifyChannel(id, token) {
     ensureLoaded();
@@ -55,3 +66,11 @@ export function channelExists(id) {
     ensureLoaded();
     return channels.has(id);
 }
+export function getChannelRecord(id) {
+    ensureLoaded();
+    return channels.get(id);
+}
+export function getChannelRetention(id) {
+    ensureLoaded();
+    return channels.get(id)?.retention ?? "none";
+}

package/dist/transcripts.js

@@ -0,0 +1,68 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+export const RETENTION_VALUES = ["none", "metadata", "prompts", "full"];
+export function isRetention(v) {
+    return typeof v === "string" && RETENTION_VALUES.includes(v);
+}
+const TRANSCRIPTS_DIR = process.env.ROGERRAT_TRANSCRIPTS ?? "./data/transcripts";
+const firstSenderByChannel = new Map();
+function pathFor(channelId) {
+    return join(TRANSCRIPTS_DIR, `${channelId}.jsonl`);
+}
+function ensureDir() {
+    if (!existsSync(TRANSCRIPTS_DIR))
+        mkdirSync(TRANSCRIPTS_DIR, { recursive: true });
+}
+function appendLine(channelId, event) {
+    ensureDir();
+    appendFileSync(pathFor(channelId), JSON.stringify(event) + "\n");
+}
+export function recordChannelCreated(channelId, retention) {
+    if (retention === "none")
+        return;
+    appendLine(channelId, { ts: Date.now(), type: "channel_created", retention });
+}
+export function recordJoin(channelId, retention, callsign) {
+    if (retention === "none")
+        return;
+    appendLine(channelId, { ts: Date.now(), type: "join", callsign });
+}
+export function recordLeave(channelId, retention, callsign) {
+    if (retention === "none")
+        return;
+    appendLine(channelId, { ts: Date.now(), type: "leave", callsign });
+}
+export function recordMessage(channelId, retention, msg) {
+    if (retention === "none")
+        return;
+    if (retention === "metadata") {
+        appendLine(channelId, {
+            ts: msg.at,
+            type: "message_meta",
+            from: msg.from,
+            to: msg.to,
+            bytes: msg.text.length,
+        });
+        return;
+    }
+    if (retention === "prompts") {
+        const seen = firstSenderByChannel.get(channelId) ?? new Set();
+        if (seen.has(msg.from))
+            return;
+        seen.add(msg.from);
+        firstSenderByChannel.set(channelId, seen);
+    }
+    appendLine(channelId, { ts: msg.at, type: "message", from: msg.from, to: msg.to, text: msg.text });
+}
+export function readTranscript(channelId, limit = 1000) {
+    const p = pathFor(channelId);
+    if (!existsSync(p))
+        return [];
+    const lines = readFileSync(p, "utf8").trim().split("\n").filter(Boolean);
+    const events = lines.map((line) => JSON.parse(line));
+    const clamped = Math.max(1, Math.min(10000, Math.floor(limit)));
+    return events.slice(-clamped);
+}
+export function hasTranscript(channelId) {
+    return existsSync(pathFor(channelId));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rogerrat",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Walkie-talkie MCP server for AI coding agents. Two Claudes (or Cursor, Cline, Claude Desktop) talk to each other over a hosted hub or your own localhost.",
   "keywords": [
     "mcp",