@tritard/waterbrother 0.16.138 → 0.16.140

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.138",
+  "version": "0.16.140",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/discord.js

@@ -18,7 +18,8 @@ import {
   releaseSharedOperator,
   removeSharedMember,
   setSharedRoom,
-  setSharedRoomMode
+  setSharedRoomMode,
+  upsertSharedAgent
 } from "./shared-project.js";
 
 const DISCORD_API_BASE = "https://discord.com/api/v10";
@@ -158,6 +159,12 @@ function buildDiscordHelp() {
     "/project show the current project and sharing state",
     "/project share enable Roundtable on the current project and bind this Discord channel",
     "/room show shared room status for the current project",
+    "/people list recently seen Discord users in this channel",
+    "/terminals list live Waterbrother terminals for this project",
+    "/executor show the selected executor",
+    "/reviewer show the assigned reviewer",
+    "/verifier show the assigned verifier",
+    "/assign-role <terminal|this terminal> <executor|reviewer|verifier|standby> assign a room role",
     "/members list shared room members",
     "/tasks list shared room tasks",
     "/events list recent shared room events",
@@ -282,6 +289,74 @@ function formatDiscordEvents(events = []) {
   ].join("\n");
 }
 
+function formatDiscordPeople({ people = [], project = null } = {}) {
+  if (!people.length) {
+    return [
+      "Recent Discord people",
+      "- none",
+      "Talk in this channel first, then run /people again."
+    ].join("\n");
+  }
+  const members = Array.isArray(project?.members) ? project.members : [];
+  const pendingInvites = Array.isArray(project?.pendingInvites) ? project.pendingInvites : [];
+  return [
+    "Recent Discord people",
+    ...people.map((person) => {
+      const member = members.find((entry) => String(entry?.id || "").trim() === person.userId);
+      const pendingInvite = pendingInvites.find((entry) => String(entry?.memberId || "").trim() === person.userId);
+      const bits = [`[${person.userId}]`];
+      if (person.usernameHandle) bits.push(person.usernameHandle);
+      bits.push(person.displayName || person.userId);
+      if (member?.role) bits.push(`member:${member.role}`);
+      else if (pendingInvite?.id) bits.push(`pending:${pendingInvite.id}`);
+      else if (person.paired) bits.push("paired");
+      return `- ${bits.join(" ")}`;
+    }),
+    "Invite by id, @username, full name, or mention with /invite."
+  ].join("\n");
+}
+
+function getAgentOwnerDisplay(agent = {}, fallback = "") {
+  return String(agent?.ownerName || fallback || agent?.label || agent?.ownerId || agent?.id || "unknown").trim() || "unknown";
+}
+
+function getAgentTerminalDisplay(agent = {}, fallback = "") {
+  return String(agent?.label || fallback || agent?.ownerName || agent?.ownerId || agent?.id || "terminal").trim() || "terminal";
+}
+
+function formatBridgeHostLabel(host = {}) {
+  const owner = String(host?.ownerName || host?.ownerId || "").trim();
+  const label = String(host?.label || "").trim();
+  const sessionSuffix = String(host?.sessionId || "").trim().slice(-6);
+  const runtime = host?.provider && host?.model ? `${host.provider}/${host.model}` : "";
+  const primary = label || owner || (sessionSuffix ? `terminal ${sessionSuffix}` : "live terminal");
+  return [primary, owner && label && owner !== label ? `(${owner})` : "", runtime ? `[${runtime}]` : ""].filter(Boolean).join(" ").trim();
+}
+
+function chooseAgentByRole(project = {}, role = "") {
+  return (Array.isArray(project?.agents) ? project.agents : []).find((agent) => String(agent?.role || "").trim() === String(role || "").trim()) || null;
+}
+
+function formatDiscordAgentStatus(title, agent = null, options = {}) {
+  if (!agent) return `${title}\nNo ${String(title || "").toLowerCase()} is assigned yet.`;
+  return [
+    title,
+    `owner: ${getAgentOwnerDisplay(agent)}`,
+    `terminal: ${getAgentTerminalDisplay(agent)}`,
+    `role: ${agent.role || "standby"}`,
+    `runtime: ${agent.provider && agent.model ? `${agent.provider}/${agent.model}` : "unknown"}`,
+    `live: ${options.live ? "yes" : "no"}`
+  ].join("\n");
+}
+
+function formatDiscordLiveHosts(hosts = []) {
+  if (!hosts.length) return "Live terminals\n- none";
+  return [
+    "Live terminals",
+    ...hosts.map((host) => `- ${formatBridgeHostLabel(host)}${host?.surface ? ` (${host.surface})` : ""}`)
+  ].join("\n");
+}
+
 function parseDiscordInviteCommand(message = {}, text = "") {
   const value = String(text || "").trim();
   const match = value.match(/^\/?(?:room\s+)?invite\s+(.+)$/i);
@@ -302,6 +377,197 @@ function parseDiscordInviteCommand(message = {}, text = "") {
   return { memberId, memberName, role };
 }
 
+function knownPersonKey(chatId, userId) {
+  return `${String(chatId || "").trim()}:${String(userId || "").trim()}`;
+}
+
+function listKnownDiscordPeople(state, message = {}) {
+  const chatId = String(message?.channel_id || "").trim();
+  const byId = new Map();
+  const upsert = (person = {}) => {
+    const userId = String(person.userId || person.id || "").trim();
+    if (!userId) return;
+    const existing = byId.get(userId) || { userId, usernameHandle: "", displayName: userId, paired: false, lastSeenAt: "" };
+    byId.set(userId, {
+      ...existing,
+      ...person,
+      userId,
+      username: String(person.username || existing.username || "").trim(),
+      usernameHandle: String(person.usernameHandle || existing.usernameHandle || "").trim(),
+      displayName: String(person.displayName || existing.displayName || userId).trim() || userId,
+      paired: person.paired === true || existing.paired === true,
+      lastSeenAt: String(person.lastSeenAt || existing.lastSeenAt || "").trim()
+    });
+  };
+
+  for (const person of Object.values(state?.knownPeople || {})) {
+    if (String(person?.chatId || "").trim() !== chatId) continue;
+    upsert(person);
+  }
+  for (const [userId, peer] of Object.entries(state?.peers || {})) {
+    if (String(peer?.chatId || "").trim() !== chatId) continue;
+    upsert({
+      userId,
+      username: String(peer?.username || "").trim(),
+      usernameHandle: String(peer?.usernameHandle || "").trim(),
+      displayName: String(peer?.displayName || peer?.username || userId).trim(),
+      paired: true,
+      lastSeenAt: String(peer?.lastSeenAt || "").trim()
+    });
+  }
+
+  const current = describeDiscordUser(message);
+  if (current.userId) upsert({ ...current, paired: Boolean(state?.peers?.[current.userId]) });
+  for (const mention of Array.isArray(message?.mentions) ? message.mentions : []) {
+    const mentioned = {
+      userId: String(mention?.id || "").trim(),
+      username: String(mention?.username || "").trim(),
+      usernameHandle: mention?.username ? `@${String(mention.username).trim()}` : "",
+      displayName: String(mention?.global_name || mention?.username || mention?.id || "").trim()
+    };
+    if (mentioned.userId) upsert(mentioned);
+  }
+
+  return [...byId.values()].sort((a, b) => {
+    const aSeen = Date.parse(String(a.lastSeenAt || "").trim()) || 0;
+    const bSeen = Date.parse(String(b.lastSeenAt || "").trim()) || 0;
+    return bSeen - aSeen || String(a.displayName || "").localeCompare(String(b.displayName || ""));
+  });
+}
+
+async function rememberKnownDiscordPeople(state, message = {}) {
+  const chatId = String(message?.channel_id || "").trim();
+  if (!chatId) return false;
+  const entries = [];
+  const author = describeDiscordUser(message);
+  if (author.userId) {
+    entries.push({
+      chatId,
+      userId: author.userId,
+      username: author.username,
+      usernameHandle: author.usernameHandle,
+      displayName: author.displayName,
+      paired: Boolean(state?.peers?.[author.userId]),
+      lastSeenAt: new Date().toISOString()
+    });
+  }
+  for (const mention of Array.isArray(message?.mentions) ? message.mentions : []) {
+    const userId = String(mention?.id || "").trim();
+    if (!userId) continue;
+    entries.push({
+      chatId,
+      userId,
+      username: String(mention?.username || "").trim(),
+      usernameHandle: mention?.username ? `@${String(mention.username).trim()}` : "",
+      displayName: String(mention?.global_name || mention?.username || mention?.id || "").trim(),
+      paired: Boolean(state?.peers?.[userId]),
+      lastSeenAt: new Date().toISOString()
+    });
+  }
+  if (!entries.length) return false;
+  const knownPeople = state.knownPeople && typeof state.knownPeople === "object" ? { ...state.knownPeople } : {};
+  for (const person of entries) {
+    knownPeople[knownPersonKey(person.chatId, person.userId)] = {
+      ...(knownPeople[knownPersonKey(person.chatId, person.userId)] || {}),
+      ...person
+    };
+  }
+  const trimmed = Object.entries(knownPeople)
+    .sort((a, b) => (Date.parse(String(b[1]?.lastSeenAt || "").trim()) || 0) - (Date.parse(String(a[1]?.lastSeenAt || "").trim()) || 0))
+    .slice(0, 250);
+  state.knownPeople = Object.fromEntries(trimmed);
+  await persistDiscordGatewayState(state);
+  return true;
+}
+
+function resolveDiscordInviteTarget(state, message = {}, rawTarget = "") {
+  const direct = parseDiscordInviteCommand(message, `/invite ${String(rawTarget || "").trim()}`);
+  if (direct?.memberId && (direct.memberId === direct.memberName || direct.memberId.match(/^\d+$/) || String(rawTarget || "").includes("<@"))) {
+    return direct;
+  }
+  const value = String(rawTarget || "").trim();
+  if (!value) return direct;
+  const known = listKnownDiscordPeople(state, message);
+  if (/^\d+$/.test(value)) {
+    const match = known.find((person) => person.userId === value);
+    return { memberId: value, memberName: match?.displayName || value, role: direct?.role || "editor" };
+  }
+  const normalized = value.replace(/^@/, "").trim().toLowerCase();
+  const byUsername = known.filter((person) => String(person.usernameHandle || "").trim().toLowerCase() === `@${normalized}` || String(person.username || "").trim().toLowerCase() === normalized);
+  if (byUsername.length === 1) {
+    return { memberId: byUsername[0].userId, memberName: byUsername[0].displayName || byUsername[0].userId, role: direct?.role || "editor" };
+  }
+  if (byUsername.length > 1) {
+    throw new Error(`Multiple Discord users matched @${normalized}. Use /people and invite by id.`);
+  }
+  const exact = known.find((person) => String(person.displayName || "").trim().toLowerCase() === normalized);
+  if (exact) {
+    return { memberId: exact.userId, memberName: exact.displayName || exact.userId, role: direct?.role || "editor" };
+  }
+  const partial = known.filter((person) => String(person.displayName || "").trim().toLowerCase().includes(normalized));
+  if (partial.length === 1) {
+    return { memberId: partial[0].userId, memberName: partial[0].displayName || partial[0].userId, role: direct?.role || "editor" };
+  }
+  if (partial.length > 1) {
+    throw new Error(`Multiple Discord users matched ${value}. Use /people and invite by id or @username.`);
+  }
+  return direct;
+}
+
+function resolveDiscordAgentTarget(project = {}, liveHosts = [], rawTarget = "") {
+  const value = String(rawTarget || "").trim().toLowerCase();
+  if (!value) return null;
+  if (/^(?:this|my)(?:\s+terminal)?$/.test(value)) {
+    const host = liveHosts[0] || null;
+    if (!host) return null;
+    return {
+      id: `agent:discord-bridge:${String(host.sessionId || host.pid || "current").trim()}`,
+      ownerId: String(host.ownerId || "").trim(),
+      ownerName: String(host.ownerName || "").trim(),
+      label: String(host.label || "").trim(),
+      surface: String(host.surface || "live-tui").trim(),
+      provider: String(host.provider || "").trim(),
+      model: String(host.model || "").trim(),
+      runtimeProfile: String(host.runtimeProfile || "").trim(),
+      sessionId: String(host.sessionId || "").trim(),
+      cwd: String(host.cwd || "").trim(),
+      role: "standby"
+    };
+  }
+  if (["executor", "reviewer", "verifier"].includes(value)) {
+    return chooseAgentByRole(project, value);
+  }
+  const candidates = [
+    ...(Array.isArray(project?.agents) ? project.agents : []),
+    ...liveHosts.map((host) => ({
+      id: `agent:discord-bridge:${String(host.sessionId || host.pid || "current").trim()}`,
+      ownerId: String(host.ownerId || "").trim(),
+      ownerName: String(host.ownerName || "").trim(),
+      label: String(host.label || "").trim(),
+      surface: String(host.surface || "live-tui").trim(),
+      provider: String(host.provider || "").trim(),
+      model: String(host.model || "").trim(),
+      runtimeProfile: String(host.runtimeProfile || "").trim(),
+      sessionId: String(host.sessionId || "").trim(),
+      cwd: String(host.cwd || "").trim(),
+      role: "standby"
+    }))
+  ];
+  const exact = candidates.find((agent) => {
+    const label = String(agent?.label || "").trim().toLowerCase();
+    const owner = String(agent?.ownerName || "").trim().toLowerCase();
+    const sessionId = String(agent?.sessionId || "").trim().toLowerCase();
+    return value === label || value === owner || value === sessionId;
+  });
+  if (exact) return exact;
+  const partial = candidates.filter((agent) => {
+    const label = String(agent?.label || "").trim().toLowerCase();
+    const owner = String(agent?.ownerName || "").trim().toLowerCase();
+    return (label && label.includes(value)) || (owner && owner.includes(value));
+  });
+  return partial.length === 1 ? partial[0] : null;
+}
+
 async function loadDiscordGatewayState() {
   return loadGatewayState("discord");
 }
@@ -710,6 +976,74 @@ async function handleDiscordControlCommand(runtime, state, message, rawText) {
       "Use /room to inspect room state."
     ].join("\n");
   }
+  if (normalized === "/terminals" || normalized === "terminals" || normalized === "/live" || normalized === "live" || normalizedRoomAlias === "terminals") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const session = await loadSession(sessionId).catch(() => null);
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    return formatDiscordLiveHosts(liveHosts);
+  }
+  if (normalized === "/executor" || normalized === "executor" || normalizedRoomAlias === "executor") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const agent = chooseAgentByRole(project, "executor");
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const live = agent ? liveHosts.some((host) => String(host?.ownerId || "") === String(agent?.ownerId || "") || String(host?.sessionId || "") === String(agent?.sessionId || "")) : false;
+    return formatDiscordAgentStatus("Executor", agent, { live });
+  }
+  if (normalized === "/reviewer" || normalized === "reviewer" || normalizedRoomAlias === "reviewer") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const agent = chooseAgentByRole(project, "reviewer");
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const live = agent ? liveHosts.some((host) => String(host?.ownerId || "") === String(agent?.ownerId || "") || String(host?.sessionId || "") === String(agent?.sessionId || "")) : false;
+    return formatDiscordAgentStatus("Reviewer", agent, { live });
+  }
+  if (normalized === "/verifier" || normalized === "verifier" || normalizedRoomAlias === "verifier") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const agent = chooseAgentByRole(project, "verifier");
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const live = agent ? liveHosts.some((host) => String(host?.ownerId || "") === String(agent?.ownerId || "") || String(host?.sessionId || "") === String(agent?.sessionId || "")) : false;
+    return formatDiscordAgentStatus("Verifier", agent, { live });
+  }
+  if (normalized.startsWith("/assign-role ") || normalizedRoomAlias.startsWith("assign-role ")) {
+    const body = normalized.startsWith("/assign-role ") ? value.slice("/assign-role ".length).trim() : roomAlias.slice("assign-role ".length).trim();
+    const match = body.match(/^(.+?)\s+(executor|reviewer|verifier|standby)\s*$/i);
+    if (!match) return "Usage: /assign-role <terminal|this terminal> <executor|reviewer|verifier|standby>";
+    const targetText = String(match[1] || "").trim();
+    const nextRole = String(match[2] || "").trim().toLowerCase();
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project, session } = await bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) return "This project is not shared.";
+    const liveHosts = await getLiveBridgeHosts({ cwd: session?.cwd || "" });
+    const targetAgent = resolveDiscordAgentTarget(project, liveHosts, targetText);
+    if (!targetAgent) {
+      return `No terminal found for ${targetText}. Use /terminals first.`;
+    }
+    const actor = describeDiscordUser(message);
+    const nextProject = await upsertSharedAgent(session.cwd || process.cwd(), {
+      ...targetAgent,
+      role: nextRole
+    }, {
+      actorId: actor.userId,
+      actorName: actor.displayName
+    });
+    return [
+      "Room role updated",
+      `owner: ${getAgentOwnerDisplay(targetAgent, actor.displayName || actor.userId)}`,
+      `terminal: ${getAgentTerminalDisplay(targetAgent, "terminal")}`,
+      `role: ${nextRole}`,
+      `project: ${nextProject.projectName || "project"}`
+    ].join("\n");
+  }
+  if (normalized === "/people" || normalized === "people" || normalizedRoomAlias === "people") {
+    const sessionId = await ensurePeerSession(runtime, state, message);
+    const { project } = await bindSharedRoomForMessage(message, sessionId);
+    return formatDiscordPeople({ people: listKnownDiscordPeople(state, message), project });
+  }
   if (normalized === "/events" || normalized === "events" || normalizedRoomAlias === "events") {
     const sessionId = await ensurePeerSession(runtime, state, message);
     const { session, project } = await bindSharedRoomForMessage(message, sessionId);
@@ -730,10 +1064,10 @@ async function handleDiscordControlCommand(runtime, state, message, rawText) {
     || normalizedRoomAlias.startsWith("invite ")
   ) {
     const sessionId = await ensurePeerSession(runtime, state, message);
-    const sourceText = normalizedRoomAlias.startsWith("invite ") ? `/invite ${roomAlias.slice("invite ".length).trim()}` : value;
-    const inviteRequest = parseDiscordInviteCommand(message, sourceText);
+    const sourceText = normalizedRoomAlias.startsWith("invite ") ? roomAlias.slice("invite ".length).trim() : value.replace(/^\/?invite\s+/i, "").trim();
+    const inviteRequest = resolveDiscordInviteTarget(state, message, sourceText);
     if (!inviteRequest?.memberId) {
-      return "Usage: /invite <@user|user-id> [owner|editor|observer]";
+      return "Usage: /invite <@user|user-id|name> [owner|editor|observer]";
     }
     const { session, project } = await bindSharedRoomForMessage(message, sessionId);
     if (!project?.enabled) return "This project is not shared.";
@@ -926,6 +1260,34 @@ async function getLiveBridgeHost({ cwd = "" } = {}) {
   return matchingHosts[0] || null;
 }
 
+async function getLiveBridgeHosts({ cwd = "" } = {}) {
+  const bridge = await loadGatewayBridge("discord");
+  const hosts = Array.isArray(bridge.hosts) ? bridge.hosts : [];
+  const nextHosts = [];
+  let changed = false;
+  for (const host of hosts) {
+    const pid = Number(host?.pid || 0);
+    if (!Number.isFinite(pid) || pid <= 0) {
+      changed = true;
+      continue;
+    }
+    try {
+      process.kill(pid, 0);
+    } catch {
+      changed = true;
+      continue;
+    }
+    nextHosts.push(host);
+  }
+  if (changed || nextHosts.length !== hosts.length) {
+    bridge.hosts = nextHosts;
+    await saveGatewayBridge("discord", bridge);
+  }
+  return cwd
+    ? nextHosts.filter((host) => !host?.cwd || String(host.cwd) === String(cwd || ""))
+    : nextHosts;
+}
+
 async function runPromptViaBridge(runtime, message, promptText, options = {}) {
   const host = await getLiveBridgeHost();
   if (!host) {
@@ -1124,10 +1486,12 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
         if (!msg || msg.author?.bot) return;
         const scope = msg.guild_id ? `guild:${msg.guild_id}` : "dm";
         log(`discord: ${scope} #${msg.channel_id} ${msg.author?.username || "unknown"} -> ${String(msg.content || "").trim()}`);
-        const shouldReply = shouldReplyToMessage(msg, botUser?.id);
-        const rawText = extractMentionContent(String(msg.content || "").trim(), botUser?.id);
-        const reply = shouldReply ? buildReply(msg, botUser?.id) : null;
         try {
+          const trackingState = await loadDiscordGatewayState();
+          await rememberKnownDiscordPeople(trackingState, msg);
+          const shouldReply = shouldReplyToMessage(msg, botUser?.id);
+          const rawText = extractMentionContent(String(msg.content || "").trim(), botUser?.id);
+          const reply = shouldReply ? buildReply(msg, botUser?.id) : null;
           if (reply) {
             await sendChannelMessage(discord, msg.channel_id, reply);
             log(`discord: replied in ${msg.channel_id}`);

package/src/gateway-state.js

@@ -19,6 +19,7 @@ function gatewayBridgePath(serviceId) {
 
 function normalizeGatewayState(parsed = {}) {
   const continuations = parsed?.continuations && typeof parsed.continuations === "object" ? parsed.continuations : {};
+  const knownPeople = parsed?.knownPeople && typeof parsed.knownPeople === "object" ? parsed.knownPeople : {};
   return {
     offset: Number.isFinite(Number(parsed?.offset)) ? Math.max(0, Math.floor(Number(parsed.offset))) : 0,
     peers: parsed?.peers && typeof parsed.peers === "object" ? parsed.peers : {},
@@ -26,6 +27,20 @@ function normalizeGatewayState(parsed = {}) {
     announcedEvents: Array.isArray(parsed?.announcedEvents)
       ? parsed.announcedEvents.map((value) => String(value || "").trim()).filter(Boolean).slice(-100)
       : [],
+    knownPeople: Object.fromEntries(
+      Object.entries(knownPeople).map(([key, item]) => [
+        key,
+        {
+          chatId: String(item?.chatId || "").trim(),
+          userId: String(item?.userId || "").trim(),
+          username: String(item?.username || "").trim(),
+          usernameHandle: String(item?.usernameHandle || "").trim(),
+          displayName: String(item?.displayName || item?.username || item?.userId || "").trim(),
+          paired: item?.paired === true,
+          lastSeenAt: String(item?.lastSeenAt || "").trim()
+        }
+      ]).filter(([, item]) => item.chatId && item.userId)
+    ),
     continuations: Object.fromEntries(
       Object.entries(continuations).map(([key, item]) => [
         key,
@@ -154,7 +169,7 @@ export async function loadGatewayState(serviceId) {
     return normalizeGatewayState(JSON.parse(raw));
   } catch (error) {
     if (error?.code === "ENOENT") {
-      return { offset: 0, peers: {}, pendingPairings: {}, announcedEvents: [], continuations: {} };
+      return { offset: 0, peers: {}, pendingPairings: {}, announcedEvents: [], knownPeople: {}, continuations: {} };
     }
     throw error;
   }