@tritard/waterbrother 0.16.127 → 0.16.129

package/package.json

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

package/src/discord.js

@@ -1,12 +1,15 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { loadGatewayBridge, saveGatewayBridge } from "./gateway-state.js";
+import { buildSelfAwarenessManifest, formatAboutWaterbrother, formatSelfState } from "./self-awareness.js";
+import { createSession, listSessions, loadSession, saveSession } from "./session-store.js";
+import { loadGatewayBridge, loadGatewayState, saveGatewayBridge, saveGatewayState } from "./gateway-state.js";
 
 const DISCORD_API_BASE = "https://discord.com/api/v10";
 const STATUS_PATH = path.join(os.homedir(), ".waterbrother", "discord-status.json");
 const DISCORD_BRIDGE_TIMEOUT_MS = 5 * 60 * 1000;
 const DISCORD_BRIDGE_POLL_MS = 250;
+const DISCORD_CONTINUATION_TTL_MS = 15 * 60 * 1000;
 
 const INTENT_BITS = {
   GUILDS: 1 << 0,
@@ -120,15 +123,95 @@ function buildReply(message, botUserId) {
   if (!content || content === "ping") {
     return "pong";
   }
-  if (normalized === "status" || normalized === "online" || normalized === "are you online") {
-    return "Discord gateway is online. I can see messages and basic mentions. Full conversational Discord runtime is the next slice.";
-  }
   if (["hello", "hi", "hey"].includes(normalized)) {
     return "Waterbrother is here. Discord setup is live at the gateway level; deeper room workflows come next.";
   }
   return null;
 }
 
+function buildDiscordHelp() {
+  return [
+    "Waterbrother Discord control",
+    "",
+    "Basic commands",
+    "/help show this help",
+    "/about show Waterbrother identity and capabilities",
+    "/state show current Waterbrother self-awareness state",
+    "/status show Discord gateway and linked remote session status",
+    "",
+    "Remote session commands",
+    "/new start a fresh remote session",
+    "/sessions list recent linked remote sessions",
+    "/resume <session-id> switch the linked remote session",
+    "/clear clear the current remote conversation history",
+    "",
+    "Use DMs or mention @Waterbrother in a server channel to run work through the live TUI."
+  ].join("\n");
+}
+
+function continuationKey(channelId, userId) {
+  return `${String(channelId || "").trim()}:${String(userId || "").trim()}`;
+}
+
+function upsertSessionHistory(existing, sessionId) {
+  const normalized = String(sessionId || "").trim();
+  if (!normalized) {
+    return Array.isArray(existing) ? existing.map((value) => String(value || "").trim()).filter(Boolean).slice(0, 12) : [];
+  }
+  const list = Array.isArray(existing) ? existing.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  return [normalized, ...list.filter((value) => value !== normalized)].slice(0, 12);
+}
+
+function buildContinuationPrompt(text = "", continuation = null) {
+  const body = String(text || "").trim();
+  if (!continuation?.lastPrompt) return body;
+  return [
+    `Your last question/request to this user was: ${continuation.lastPrompt}`,
+    "",
+    `Their follow-up reply is: ${body}`
+  ].join("\n");
+}
+
+function formatSessionList(currentSessionId, sessions = []) {
+  if (!sessions.length) {
+    return "Remote sessions\nNo linked remote sessions yet.";
+  }
+  const lines = ["Remote sessions"];
+  for (const session of sessions) {
+    const id = String(session?.id || "").trim();
+    if (!id) continue;
+    const current = id === String(currentSessionId || "").trim() ? " (current)" : "";
+    const preview = String(session?.lastUserPreview || "").trim();
+    const updatedAt = String(session?.updatedAt || "").trim();
+    lines.push(`- ${id}${current}`);
+    if (updatedAt) lines.push(`  updated: ${updatedAt}`);
+    if (preview) lines.push(`  last: ${preview.slice(0, 120)}`);
+  }
+  return lines.join("\n");
+}
+
+function parseDiscordSessionCommand(text = "") {
+  const value = String(text || "").trim();
+  if (!value) return null;
+  const normalized = value.replace(/\s+/g, " ").trim().toLowerCase();
+  if (normalized === "/new" || normalized === "new session" || normalized === "start a new session" || normalized === "fresh session") {
+    return { type: "new" };
+  }
+  if (normalized === "/clear" || normalized === "clear session" || normalized === "clear conversation" || normalized === "clear history") {
+    return { type: "clear" };
+  }
+  if (normalized === "/sessions" || normalized === "list sessions" || normalized === "show sessions") {
+    return { type: "sessions" };
+  }
+  if (normalized.startsWith("/resume ")) {
+    return { type: "resume", sessionId: value.slice("/resume ".length).trim() };
+  }
+  if (normalized.startsWith("resume ")) {
+    return { type: "resume", sessionId: value.slice(value.toLowerCase().indexOf("resume ") + "resume ".length).trim() };
+  }
+  return null;
+}
+
 function createBridgeRequestId() {
   return `dc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
 }
@@ -141,10 +224,269 @@ function describeDiscordUser(message = {}) {
   return {
     userId: String(author.id || "").trim(),
     username,
+    usernameHandle: username ? `@${username}` : "",
     displayName
   };
 }
 
+async function loadDiscordGatewayState() {
+  return loadGatewayState("discord");
+}
+
+async function persistDiscordGatewayState(state) {
+  return saveGatewayState("discord", state);
+}
+
+function getPeerState(state, userId) {
+  return state?.peers?.[String(userId || "").trim()] || null;
+}
+
+function getPendingContinuation(state, message) {
+  const key = continuationKey(message?.channel_id, message?.author?.id);
+  const item = state?.continuations?.[key];
+  if (!item) return null;
+  const expiresAtMs = Date.parse(String(item.expiresAt || ""));
+  if (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) return null;
+  return item;
+}
+
+function clearContinuation(state, message) {
+  const key = continuationKey(message?.channel_id, message?.author?.id);
+  if (state?.continuations?.[key]) {
+    delete state.continuations[key];
+    return true;
+  }
+  return false;
+}
+
+async function rememberContinuation(state, message, text = "") {
+  const body = String(text || "").trim();
+  if (!body) return false;
+  const asksFollowUp =
+    /\?\s*$/.test(body)
+    || /\b(would you like|do you want|which\b|what\b.*\?|how\b.*\?|who\b.*\?|where\b.*\?)\b/i.test(body);
+  if (!asksFollowUp) return false;
+  const key = continuationKey(message?.channel_id, message?.author?.id);
+  state.continuations[key] = {
+    chatId: String(message?.channel_id || "").trim(),
+    userId: String(message?.author?.id || "").trim(),
+    lastPrompt: body.slice(0, 400),
+    kind: "follow-up",
+    source: "assistant-question",
+    context: {},
+    expiresAt: new Date(Date.now() + DISCORD_CONTINUATION_TTL_MS).toISOString()
+  };
+  await persistDiscordGatewayState(state);
+  return true;
+}
+
+async function ensurePeerSession(runtime, state, message) {
+  const actor = describeDiscordUser(message);
+  const existing = getPeerState(state, actor.userId);
+  if (existing?.sessionId) {
+    state.peers[actor.userId] = {
+      ...existing,
+      chatId: String(message.channel_id || "").trim(),
+      username: actor.displayName,
+      usernameHandle: actor.usernameHandle,
+      displayName: actor.displayName,
+      sessions: upsertSessionHistory(existing.sessions, existing.sessionId),
+      lastSeenAt: new Date().toISOString(),
+      lastMessageId: String(message.id || "").trim()
+    };
+    await persistDiscordGatewayState(state);
+    return existing.sessionId;
+  }
+
+  const session = await createSession({
+    cwd: process.cwd(),
+    model: runtime.model,
+    agentProfile: runtime.agentProfile || "coder"
+  });
+  session.provider = runtime.provider;
+  session.baseUrl = runtime.baseUrl;
+  session.designModel = runtime.designModel;
+  session.runtimeProfile = runtime?.channels?.discord?.defaultRuntimeProfile || runtime?.gateway?.defaultRuntimeProfile || null;
+  await saveSession(session);
+
+  state.peers[actor.userId] = {
+    sessionId: session.id,
+    chatId: String(message.channel_id || "").trim(),
+    username: actor.displayName,
+    usernameHandle: actor.usernameHandle,
+    displayName: actor.displayName,
+    sessions: upsertSessionHistory([], session.id),
+    linkedAt: new Date().toISOString(),
+    lastSeenAt: new Date().toISOString(),
+    lastMessageId: String(message.id || "").trim()
+  };
+  await persistDiscordGatewayState(state);
+  return session.id;
+}
+
+async function startFreshSession(runtime, state, message) {
+  const actor = describeDiscordUser(message);
+  const session = await createSession({
+    cwd: process.cwd(),
+    model: runtime.model,
+    agentProfile: runtime.agentProfile || "coder"
+  });
+  session.provider = runtime.provider;
+  session.baseUrl = runtime.baseUrl;
+  session.designModel = runtime.designModel;
+  session.runtimeProfile = runtime?.channels?.discord?.defaultRuntimeProfile || runtime?.gateway?.defaultRuntimeProfile || null;
+  await saveSession(session);
+
+  const previous = getPeerState(state, actor.userId) || {};
+  state.peers[actor.userId] = {
+    ...previous,
+    sessionId: session.id,
+    chatId: String(message.channel_id || "").trim(),
+    username: actor.displayName,
+    usernameHandle: actor.usernameHandle,
+    displayName: actor.displayName,
+    sessions: upsertSessionHistory(previous.sessions, session.id),
+    linkedAt: new Date().toISOString(),
+    lastSeenAt: new Date().toISOString(),
+    lastMessageId: String(message.id || "").trim()
+  };
+  clearContinuation(state, message);
+  await persistDiscordGatewayState(state);
+  return session.id;
+}
+
+async function listPeerSessions(state, userId) {
+  const peer = getPeerState(state, userId);
+  const ids = Array.isArray(peer?.sessions) ? peer.sessions.map((value) => String(value || "").trim()).filter(Boolean) : [];
+  if (!ids.length && peer?.sessionId) ids.push(String(peer.sessionId));
+  if (!ids.length) return [];
+  const all = await listSessions(Math.max(20, ids.length + 4));
+  const byId = new Map(all.map((session) => [session.id, session]));
+  return ids.map((id) => byId.get(id) || { id }).filter(Boolean);
+}
+
+async function resumePeerSession(state, message, sessionId) {
+  const actor = describeDiscordUser(message);
+  const normalizedId = String(sessionId || "").trim();
+  if (!normalizedId) throw new Error("Usage: /resume <session-id>");
+  const session = await loadSession(normalizedId);
+  const previous = getPeerState(state, actor.userId) || {};
+  state.peers[actor.userId] = {
+    ...previous,
+    sessionId: session.id,
+    chatId: String(message.channel_id || "").trim(),
+    username: actor.displayName,
+    usernameHandle: actor.usernameHandle,
+    displayName: actor.displayName,
+    sessions: upsertSessionHistory(previous.sessions, session.id),
+    linkedAt: previous.linkedAt || new Date().toISOString(),
+    lastSeenAt: new Date().toISOString(),
+    lastMessageId: String(message.id || "").trim()
+  };
+  clearContinuation(state, message);
+  await persistDiscordGatewayState(state);
+  return session.id;
+}
+
+async function clearRemoteConversation(sessionId) {
+  const session = await loadSession(sessionId);
+  session.messages = [];
+  session.runState = {
+    state: "done",
+    detail: "",
+    updatedAt: new Date().toISOString()
+  };
+  await saveSession(session);
+}
+
+async function handleDiscordSessionCommand(runtime, state, message, command) {
+  const actor = describeDiscordUser(message);
+  if (command.type === "new") {
+    const sessionId = await startFreshSession(runtime, state, message);
+    return `Started new remote session: ${sessionId}`;
+  }
+  if (command.type === "sessions") {
+    const sessions = await listPeerSessions(state, actor.userId);
+    const currentSessionId = getPeerState(state, actor.userId)?.sessionId || "";
+    return formatSessionList(currentSessionId, sessions);
+  }
+  if (command.type === "resume") {
+    if (!command.sessionId) {
+      return "Usage: /resume <session-id>\nUse /sessions to list recent remote session ids.";
+    }
+    const sessionId = await resumePeerSession(state, message, command.sessionId);
+    return `Linked remote session: ${sessionId}`;
+  }
+  if (command.type === "clear") {
+    const sessionId = getPeerState(state, actor.userId)?.sessionId || await ensurePeerSession(runtime, state, message);
+    await clearRemoteConversation(sessionId);
+    clearContinuation(state, message);
+    await persistDiscordGatewayState(state);
+    return `Cleared conversation history for ${sessionId}.`;
+  }
+  return null;
+}
+
+async function buildDiscordAbout(runtime, state, message) {
+  const actor = describeDiscordUser(message);
+  const sessionId = getPeerState(state, actor.userId)?.sessionId || "";
+  const currentSession = sessionId ? await loadSession(sessionId).catch(() => null) : null;
+  const manifest = await buildSelfAwarenessManifest({
+    cwd: currentSession?.cwd || process.cwd(),
+    runtime,
+    currentSession
+  });
+  return formatAboutWaterbrother(manifest);
+}
+
+async function buildDiscordState(runtime, state, message) {
+  const actor = describeDiscordUser(message);
+  const sessionId = getPeerState(state, actor.userId)?.sessionId || "";
+  const currentSession = sessionId ? await loadSession(sessionId).catch(() => null) : null;
+  const manifest = await buildSelfAwarenessManifest({
+    cwd: currentSession?.cwd || process.cwd(),
+    runtime,
+    currentSession
+  });
+  return formatSelfState(manifest);
+}
+
+async function buildDiscordStatusMessage(runtime, state, message) {
+  const discord = normalizeDiscordRuntime(runtime);
+  const actor = describeDiscordUser(message);
+  const peer = getPeerState(state, actor.userId);
+  const sessionId = String(peer?.sessionId || "").trim();
+  const session = sessionId ? await loadSession(sessionId).catch(() => null) : null;
+  const liveHost = await getLiveBridgeHost({ cwd: session?.cwd || "" });
+  return [
+    "Discord status",
+    `gateway: ${discord.enabled && discord.token && discord.applicationId ? "configured" : "incomplete"}`,
+    `application id: ${discord.applicationId || "missing"}`,
+    `linked session: ${sessionId || "none"}`,
+    session?.cwd ? `cwd: ${session.cwd}` : "",
+    session?.runtimeProfile ? `runtime profile: ${session.runtimeProfile}` : "",
+    liveHost ? `live terminal: ${String(liveHost.label || liveHost.ownerName || liveHost.sessionId || "connected").trim()}` : "live terminal: not connected"
+  ].filter(Boolean).join("\n");
+}
+
+async function handleDiscordControlCommand(runtime, state, message, rawText) {
+  const normalized = String(rawText || "").replace(/\s+/g, " ").trim().toLowerCase();
+  if (!normalized) return null;
+  if (normalized === "/help" || normalized === "help") {
+    return buildDiscordHelp();
+  }
+  if (normalized === "/about" || normalized === "about") {
+    return buildDiscordAbout(runtime, state, message);
+  }
+  if (normalized === "/state" || normalized === "state") {
+    return buildDiscordState(runtime, state, message);
+  }
+  if (normalized === "/status" || normalized === "status" || normalized === "online" || normalized === "are you online") {
+    return buildDiscordStatusMessage(runtime, state, message);
+  }
+  return null;
+}
+
 async function getLiveBridgeHost({ cwd = "" } = {}) {
   const bridge = await loadGatewayBridge("discord");
   const hosts = Array.isArray(bridge.hosts) ? bridge.hosts : [];
@@ -178,7 +520,7 @@ async function getLiveBridgeHost({ cwd = "" } = {}) {
   return bridge.activeHost?.pid ? bridge.activeHost : (nextHosts[0] || null);
 }
 
-async function runPromptViaBridge(runtime, message, promptText) {
+async function runPromptViaBridge(runtime, message, promptText, options = {}) {
   const host = await getLiveBridgeHost();
   if (!host) {
     return { error: "No live Waterbrother TUI is connected. Start Waterbrother in the terminal first, then retry." };
@@ -195,7 +537,7 @@ async function runPromptViaBridge(runtime, message, promptText) {
     username: actor.username,
     usernameHandle: actor.username ? `@${actor.username}` : "",
     displayName: actor.displayName,
-    sessionId: "",
+    sessionId: String(options.sessionId || "").trim(),
     text: String(promptText || "").trim(),
     requestKind: "prompt",
     explicitExecution: true,
@@ -226,7 +568,11 @@ async function runPromptViaBridge(runtime, message, promptText) {
       if (reply.error) {
         return { error: String(reply.error || "").trim() || "Discord bridge execution failed." };
       }
-      return { content: String(reply.content || "").trim() || "(no content)" };
+      return {
+        content: String(reply.content || "").trim() || "(no content)",
+        sessionId: String(reply.sessionId || "").trim(),
+        meta: reply.meta && typeof reply.meta === "object" ? { ...reply.meta } : {}
+      };
     }
   }
 
@@ -372,19 +718,43 @@ 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 reply = shouldReplyToMessage(msg, botUser?.id)
-          ? buildReply(msg, botUser?.id)
-          : null;
+        const shouldReply = shouldReplyToMessage(msg, botUser?.id);
+        const rawText = extractMentionContent(String(msg.content || "").trim(), botUser?.id);
+        const reply = shouldReply ? buildReply(msg, botUser?.id) : null;
         try {
           if (reply) {
             await sendChannelMessage(discord, msg.channel_id, reply);
             log(`discord: replied in ${msg.channel_id}`);
             return;
           }
-          if (shouldReplyToMessage(msg, botUser?.id)) {
-            const bridged = await runPromptViaBridge(runtime, msg, extractMentionContent(String(msg.content || "").trim(), botUser?.id));
+          if (shouldReply) {
+            const state = await loadDiscordGatewayState();
+            const controlReply = await handleDiscordControlCommand(runtime, state, msg, rawText);
+            if (controlReply) {
+              await sendChannelMessage(discord, msg.channel_id, controlReply);
+              log(`discord: control reply in ${msg.channel_id}`);
+              return;
+            }
+            const command = parseDiscordSessionCommand(rawText);
+            if (command) {
+              const commandReply = await handleDiscordSessionCommand(runtime, state, msg, command);
+              if (commandReply) {
+                await sendChannelMessage(discord, msg.channel_id, commandReply);
+                log(`discord: session reply in ${msg.channel_id}`);
+              }
+              return;
+            }
+            const continuation = getPendingContinuation(state, msg);
+            const stateChanged = clearContinuation(state, msg);
+            if (stateChanged) {
+              await persistDiscordGatewayState(state);
+            }
+            const sessionId = await ensurePeerSession(runtime, state, msg);
+            const promptText = continuation ? buildContinuationPrompt(rawText, continuation) : rawText;
+            const bridged = await runPromptViaBridge(runtime, msg, promptText, { sessionId });
             if (bridged?.content) {
               await sendChannelMessage(discord, msg.channel_id, bridged.content);
+              await rememberContinuation(state, msg, bridged.content);
               log(`discord: bridged reply in ${msg.channel_id}`);
             } else if (bridged?.error) {
               await sendChannelMessage(discord, msg.channel_id, bridged.error);