roger-roger 0.1.0

package/skills/roger-roger/scripts/inbox.mjs

@@ -0,0 +1,381 @@
+// Messages the user sends the bot in Slack, and getting each one to the right agent.
+//
+// The daemon is always connected, so a message is taken in the moment it is sent, whether or not any
+// agent happens to be waiting. Where it goes is decided by router.mjs; this file does what that
+// decision says: drops a note on a progress message, answers a question, hands a message to a
+// session's queue, or — when several agents are running and nothing says which — asks the user which
+// one it is for, with a button per session in that session's colour.
+//
+// Reactions say what has happened to a message: 👀 an agent has it, ✅ an agent has answered it.
+// Reading a message is not the same as acting on one — an agent parked on `listen` picks a message
+// up instantly, so marking that as done told the user nothing.
+
+import fs from "node:fs";
+import path from "node:path";
+import { rogerRogerHome, isUserId, loadConfig, pickedBlocks, pickerBlocks, progressBlocks, sentToBlocks, stripTags, NOBODY } from "./lib.mjs";
+import { addReaction, downloadFile, history, openDm, postToChannel, replies, updateMessage } from "./slack.mjs";
+import { routeMessage } from "./router.mjs";
+import * as progressStore from "./progress.mjs";
+import * as sessions from "./sessions.mjs";
+import * as decisions from "./decisions.mjs";
+
+const KEEP = 200;
+
+function file() {
+  return path.join(rogerRogerHome(), "inbox.json");
+}
+
+function readState() {
+  try {
+    return JSON.parse(fs.readFileSync(file(), "utf8"));
+  } catch {
+    return { channel: "", lastTs: "", messages: [] };
+  }
+}
+
+function writeState(state) {
+  fs.mkdirSync(path.dirname(file()), { recursive: true });
+  const tmp = `${file()}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify({ ...state, messages: state.messages.slice(-KEEP) }, null, 2) + "\n", "utf8");
+  fs.renameSync(tmp, file());
+}
+
+// A message carrying a file arrives as a subtype, not as a plain message. Dropping those lost
+// screenshots entirely — the most useful thing the user can send — so they are let through, and so
+// is a file posted with no caption at all.
+const CARRIES_FILES = new Set(["file_share", "thread_broadcast"]);
+
+/** A Slack message the user wrote (not the bot's own posts, edits, joins, …). */
+export function isUserMessage(m) {
+  if (!m || !m.user || m.bot_id) return false;
+  if (m.subtype && !CARRIES_FILES.has(m.subtype)) return false;
+  const text = typeof m.text === "string" ? m.text.trim() : "";
+  return Boolean(text || (Array.isArray(m.files) && m.files.length));
+}
+
+const tsIso = (ts) => new Date(Math.floor(Number(ts) * 1000)).toISOString();
+
+const filesDir = () => path.join(rogerRogerHome(), "files");
+
+// Attachments are a convenience, not a record. Decisions are kept a week; so are these.
+const KEEP_FILES_MS = 7 * 24 * 3600 * 1000;
+
+function pruneFiles(now = Date.now()) {
+  let names;
+  try {
+    names = fs.readdirSync(filesDir());
+  } catch {
+    return;
+  }
+  for (const name of names) {
+    const file = path.join(filesDir(), name);
+    try {
+      if (now - fs.statSync(file).mtimeMs > KEEP_FILES_MS) fs.rmSync(file, { force: true });
+    } catch {
+      // A file that vanished or can't be read is not worth failing an incoming message over.
+    }
+  }
+}
+
+/**
+ * Bring down whatever the user attached, so the agent is handed a path it can open rather than a
+ * Slack URL it cannot read. One that won't come down is still reported, with the reason.
+ */
+async function takeFiles(message, log) {
+  const shared = Array.isArray(message.files) ? message.files : [];
+  if (shared.length) pruneFiles();
+  const saved = [];
+  for (const f of shared) {
+    const about = { name: f.name ?? f.title ?? f.id, mimetype: f.mimetype ?? "", size: f.size ?? null, permalink: f.permalink ?? null };
+    try {
+      saved.push({ ...about, path: await downloadFile(f, filesDir()) });
+    } catch (e) {
+      log(`could not save ${about.name}: ${e.message}`);
+      saved.push({ ...about, path: null, error: e.message });
+    }
+  }
+  return saved;
+}
+
+const ATTENDING = new Set(["listening", "working", "waiting"]);
+const RECENTLY_MS = 2 * 60 * 1000;
+
+/**
+ * Which reaction says the truth. :eyes: means someone is there — parked on `listen`, or running
+ * commands right now. :zzz: means the message is kept but the agent is idle, so it arrives at that
+ * agent's next step rather than in a moment. Guessing between those two was the thing the user
+ * could not do from Slack.
+ */
+export function reactionFor(route) {
+  if (route.kind !== "session") return "eyes";
+  const session = sessions.get(route.id);
+  if (!session) return "zzz";
+  if (session.state === "listening") return "eyes";
+  const recent = Date.now() - Date.parse(session.lastSeen ?? 0) < RECENTLY_MS;
+  return recent && ATTENDING.has(session.state) ? "eyes" : "zzz";
+}
+
+/** The world as the router sees it. */
+function snapshot() {
+  return {
+    progress: progressStore.active(),
+    pending: decisions.list().filter((d) => d.status === "pending"),
+    sessions: sessions.live(),
+    threads: sessions.threads(),
+  };
+}
+
+/** Take one message in: route it, act on it, react 👀. Already-seen messages are ignored. */
+export async function ingest(message, { log = () => {}, live = false, waiting = () => false } = {}) {
+  if (!isUserMessage(message)) return null;
+  // The message is claimed before anything is awaited. Downloading its files takes a while, and
+  // the same message can arrive twice in that time (the live event, and a sync after a
+  // reconnect): a claim written only afterwards let both through. Every write below re-reads the
+  // file first, so an entry another ingest wrote while this one was downloading is kept, not
+  // overwritten with the state as it was before the download.
+  const state = readState();
+  if (state.messages.some((m) => m.ts === message.ts)) return null;
+  const channel = message.channel || state.channel;
+  const text = String(message.text ?? "");
+  const claim = {
+    ts: message.ts,
+    threadTs: message.thread_ts ?? null,
+    channel,
+    text,
+    user: message.user,
+    // Not routed yet: nothing hands out or re-routes a message in this state.
+    route: { kind: "pending" },
+    receivedAt: new Date().toISOString(),
+  };
+  writeState({ ...state, channel: state.channel || channel, messages: [...state.messages, claim] });
+
+  let entry;
+  try {
+    const files = await takeFiles(message, log);
+    const route = routeMessage(message, snapshot());
+    entry = { ...claim, ...(files.length ? { files } : {}), route };
+  } catch (e) {
+    // Let go of the claim, so the next sync can take the message in rather than it being lost.
+    const now = readState();
+    writeState({ ...now, messages: now.messages.filter((m) => m.ts !== message.ts) });
+    throw e;
+  }
+  const now = readState();
+  const claimed = now.messages.some((m) => m.ts === entry.ts);
+  writeState({ ...now, messages: claimed ? now.messages.map((m) => (m.ts === entry.ts ? entry : m)) : [...now.messages, entry] });
+  const route = entry.route;
+  const files = entry.files ?? [];
+  log(`message ${message.ts} → ${route.kind}${route.key ? ` ${route.key}` : route.id ? ` ${route.id}` : ""}`);
+
+  await addReaction(channel, message.ts, reactionFor(route)).catch((e) => log(`reaction failed: ${e.message}`));
+
+  if (route.kind === "progress") {
+    await addNote(route.key, message, channel, files);
+    if (route.session) sessions.bindThread(message.thread_ts ?? message.ts, route.session);
+  } else if (route.kind === "decision") {
+    const settled = await decisions.settle(route.id, {
+      status: "answered",
+      answer: { index: null, choice: null, text: text.trim(), by: message.user, via: "message", ...(files.length ? { files } : {}) },
+    }, log, { waiting: waiting(route.id) });
+    if (settled) await addReaction(channel, message.ts, "white_check_mark").catch(() => {});
+  } else if (route.kind === "session") {
+    deliver(route.id, { text: route.text ?? text, by: message.user, at: tsIso(message.ts), ts: message.ts, threadTs: message.thread_ts ?? null, channel, via: route.via, ...(files.length ? { files } : {}) });
+    sessions.bindThread(message.thread_ts ?? message.ts, route.id);
+    if (route.via === "listening") await sayWhereItWent(entry, route.id, log);
+  } else if (route.kind === "ask") {
+    await askWhichSession(entry, log);
+  } else if (route.kind === "inbox" && live) {
+    await postToChannel(channel, {
+      text: "📥 No agent is running right now, so nobody can read this yet. It's saved, and the next agent you start will get it when it checks its messages.",
+      thread_ts: message.ts,
+    }).catch((e) => log(`inbox reply failed: ${e.message}`));
+  }
+  return entry;
+}
+
+/** A note on a progress message, shown in it and delivered at the agent's next check. */
+async function addNote(key, message, channel, files = []) {
+  const p = progressStore.current(key);
+  if (!p) return;
+  const note = { text: String(message.text ?? ""), by: message.user, at: tsIso(message.ts), slackTs: message.ts, channel, ...(files.length ? { files } : {}) };
+  const next = { ...p, notes: [...(p.notes ?? []), note] };
+  progressStore.save(key, next);
+  await updateMessage(p.channel, p.ts, {
+    text: stripTags(p.headline),
+    blocks: progressBlocks({ ...next, key }),
+    color: p.colour,
+  }).catch(() => {});
+}
+
+function deliver(sessionId, message) {
+  sessions.enqueue(sessionId, message);
+  sessions.touch(sessionId, {});
+}
+
+/** Several agents are running: ask which one, in the thread of the message itself. */
+/** Own the guess: say which agent got it, and put the others one tap away. */
+async function sayWhereItWent(entry, sessionId, log) {
+  const chosen = sessions.get(sessionId);
+  if (!chosen) return;
+  const decorated = sessions.decorate(chosen);
+  const others = sessions.live().filter((s) => s.id !== sessionId);
+  try {
+    const note = await postToChannel(entry.channel, {
+      text: `Sent to ${chosen.nickname}`,
+      blocks: sentToBlocks({ text: entry.text, session: decorated, others, messageTs: entry.ts }),
+      thread_ts: entry.ts,
+      color: decorated.colour,
+    });
+    const state = readState();
+    writeState({ ...state, messages: state.messages.map((m) => (m.ts === entry.ts ? { ...m, pickerTs: note.ts } : m)) });
+  } catch (e) {
+    log(`could not say where the message went: ${e.message}`);
+  }
+}
+
+async function askWhichSession(entry, log) {
+  const live = sessions.live();
+  try {
+    const picker = await postToChannel(entry.channel, {
+      text: "Which agent is this for?",
+      blocks: pickerBlocks({ text: entry.text, sessions: live, messageTs: entry.ts }),
+      thread_ts: entry.ts,
+    });
+    const state = readState();
+    writeState({
+      ...state,
+      messages: state.messages.map((m) => (m.ts === entry.ts ? { ...m, pickerTs: picker.ts, candidates: live.map((s) => s.id) } : m)),
+    });
+  } catch (e) {
+    // Without buttons the message still isn't lost: it falls back to the inbox.
+    log(`could not ask which session: ${e.message}`);
+    const state = readState();
+    writeState({ ...state, messages: state.messages.map((m) => (m.ts === entry.ts ? { ...m, route: { kind: "inbox" } } : m)) });
+  }
+}
+
+/**
+ * The user picked a session from the buttons. The message goes to it, the thread is remembered so
+ * the next reply needs no picker, and the buttons are replaced by where it went.
+ */
+export async function resolvePick(messageTs, sessionId, log = () => {}) {
+  const state = readState();
+  const entry = state.messages.find((m) => m.ts === messageTs);
+  // Either the user is answering the picker, or they are correcting a message that was sent to the
+  // one agent that happened to be listening.
+  if (!entry || (entry.route.kind !== "ask" && entry.route.via !== "listening")) return null;
+
+  const chosen = sessionId === NOBODY ? null : sessions.get(sessionId);
+  const route = chosen ? { kind: "session", id: chosen.id, via: "picked" } : { kind: "inbox" };
+  writeState({ ...state, messages: state.messages.map((m) => (m.ts === messageTs ? { ...m, route } : m)) });
+
+  if (chosen) {
+    deliver(chosen.id, { text: entry.text, by: entry.user, at: tsIso(entry.ts), ts: entry.ts, channel: entry.channel, via: "picked" });
+    sessions.bindThread(entry.ts, chosen.id);
+    log(`message ${messageTs} → ${chosen.nickname}`);
+  } else {
+    log(`message ${messageTs} → inbox (nobody)`);
+  }
+
+  if (entry.pickerTs) {
+    await updateMessage(entry.channel, entry.pickerTs, {
+      text: chosen ? `Sent to ${chosen.nickname}` : "Kept for the next agent",
+      blocks: pickedBlocks({ text: entry.text, session: chosen ? sessions.decorate(chosen) : null }),
+      color: chosen ? sessions.decorate(chosen).colour : undefined,
+    }).catch((e) => log(`could not update the picker: ${e.message}`));
+  }
+  return route;
+}
+
+/** The DM channel with the configured user, remembered once found. Null when Slack isn't a DM. */
+async function dmChannel(state) {
+  if (state.channel) return state.channel;
+  const target = loadConfig()?.slack?.target ?? "";
+  if (!isUserId(target)) return null;
+  return openDm(target);
+}
+
+/**
+ * Catch up on messages Slack has that haven't been taken in yet. With an always-on daemon this is
+ * only needed after downtime — a reboot, or the daemon being restarted — but it costs little and
+ * means nothing sent while nothing was listening is lost. The first sync only sets a starting point,
+ * so old conversation history is never replayed.
+ */
+export async function sync({ log = () => {} } = {}) {
+  const state = readState();
+  const channel = await dmChannel(state).catch(() => null);
+  if (!channel) return [];
+  const nowTs = (Date.now() / 1000).toFixed(6);
+  if (!state.lastTs) {
+    // Re-read: finding the DM channel was a network call, and a live message may have landed since.
+    writeState({ ...readState(), channel, lastTs: nowTs });
+    return [];
+  }
+
+  const found = [...(await history(channel, state.lastTs))];
+  const threads = [
+    ...progressStore.active().map((p) => p.ts),
+    ...decisions.list().filter((d) => d.status === "pending" && d.channel === channel).map((d) => d.ts),
+    ...Object.keys(sessions.threads()),
+  ];
+  for (const ts of new Set(threads)) {
+    found.push(...(await replies(channel, ts, state.lastTs).catch(() => [])));
+  }
+  const taken = [];
+  for (const m of found.sort((a, b) => Number(a.ts) - Number(b.ts))) {
+    if (Number(m.ts) <= Number(state.lastTs)) continue;
+    const entry = await ingest({ ...m, channel }, { log });
+    if (entry) taken.push(entry);
+  }
+  const latest = readState();
+  const maxTs = found.reduce((max, m) => (Number(m.ts) > Number(max) ? m.ts : max), state.lastTs);
+  writeState({ ...latest, channel, lastTs: maxTs });
+  return taken;
+}
+
+/** Mark messages as read, so nothing an agent has already been given is handed out twice. */
+function markRead(timestamps) {
+  const seen = new Set(timestamps.filter(Boolean));
+  if (!seen.size) return;
+  const state = readState();
+  const now = new Date().toISOString();
+  writeState({ ...state, messages: state.messages.map((m) => (seen.has(m.ts) && !m.readAt ? { ...m, readAt: now } : m)) });
+}
+
+/** Everything queued for one session, handed over and ✅ in Slack. */
+export async function takeForSession(id) {
+  const queued = sessions.drain(id);
+  if (!queued.length) return [];
+  markRead(queued.map((m) => m.ts));
+  // `replyTo` is the thread to answer in: the one the user wrote in, or the message itself.
+  return queued.map((m) => ({
+    text: m.text,
+    by: m.by,
+    at: m.at,
+    ...(m.via ? { via: m.via } : {}),
+    ...(m.threadTs || m.ts ? { replyTo: m.threadTs || m.ts } : {}),
+    ...(m.files?.length ? { files: m.files } : {}),
+  }));
+}
+
+/**
+ * Unread inbox messages, marked read and ✅: the first agent to ask gets them. Includes messages that
+ * were waiting for a session that has since gone, since nobody is coming back for those.
+ */
+export async function takeInbox() {
+  const state = readState();
+  // A message still sitting in a session's queue when that session goes is nobody's until someone
+  // asks for it; one already handed over has been read and never comes back.
+  const orphaned = (m) => m.route.kind === "session" && !sessions.isLive(sessions.get(m.route.id));
+  const unread = state.messages.filter((m) => (m.route.kind === "inbox" || orphaned(m)) && !m.readAt);
+  if (!unread.length) return [];
+  const now = new Date().toISOString();
+  writeState({ ...state, messages: state.messages.map((m) => (unread.includes(m) ? { ...m, readAt: now } : m)) });
+  // No tick here either: an agent taking a message is not the same as answering it.
+  return unread.map((m) => ({ text: m.text, by: m.user, at: tsIso(m.ts) }));
+}
+
+/** ✅ on Slack messages that just became read as progress notes. */
+export async function markNotesRead(notes) {
+  await Promise.all(notes.filter((n) => n.slackTs && n.channel).map((n) => addReaction(n.channel, n.slackTs, "white_check_mark").catch(() => {})));
+}