@tritard/waterbrother 0.16.123 → 0.16.125

package/package.json

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

package/src/cli.js

@@ -107,6 +107,7 @@ const PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)),
 const BIN_PATH = path.join(PACKAGE_ROOT, "bin", "waterbrother.js");
 const DOCS_BASE_URL = String(process.env.WATERBROTHER_DOCS_BASE_URL || "https://waterbrother.app").trim().replace(/\/+$/, "");
 const TELEGRAM_BRIDGE_SERVICE = "telegram";
+const DISCORD_BRIDGE_SERVICE = "discord";
 const TELEGRAM_BRIDGE_POLL_MS = 250;
 
 
@@ -3036,6 +3037,10 @@ function upsertTelegramBridgeHostEntry(hosts = [], nextHost = {}) {
   return filtered.slice(0, 20);
 }
 
+function bridgeServicesForLiveTui() {
+  return [TELEGRAM_BRIDGE_SERVICE, DISCORD_BRIDGE_SERVICE];
+}
+
 async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
   try {
     const project = await loadSharedProject(cwd);
@@ -3065,53 +3070,70 @@ async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
 }
 
 async function registerTelegramBridgeHost({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "", actor = null }) {
-  const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
-  bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
-  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
-  bridge.deliveredReplies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies.slice(-50) : [];
-  bridge.pendingRequests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
-  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
-  await syncSharedTelegramBridgeAgent({ cwd, host: bridge.activeHost, actor: actor || { id: ownerId, name: ownerName } });
-  return bridge.activeHost;
+  const hostRecord = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
+  for (const serviceId of bridgeServicesForLiveTui()) {
+    const bridge = await loadGatewayBridge(serviceId);
+    bridge.activeHost = hostRecord;
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+    bridge.deliveredReplies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies.slice(-50) : [];
+    bridge.pendingRequests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
+    await saveGatewayBridge(serviceId, bridge);
+  }
+  await syncSharedTelegramBridgeAgent({ cwd, host: hostRecord, actor: actor || { id: ownerId, name: ownerName } });
+  return hostRecord;
 }
 
 async function touchTelegramBridgeHost({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "", actor = null }) {
-  const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
-  const activeHost = bridge.activeHost || {};
-  if (Number(activeHost.pid || 0) !== process.pid) {
-    bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
-  } else {
-    bridge.activeHost = {
-      ...activeHost,
-      sessionId: String(sessionId || "").trim(),
-      cwd: String(cwd || "").trim(),
-      label: String(label || activeHost.label || "").trim(),
-      surface: String(surface || activeHost.surface || "live-tui").trim() || "live-tui",
-      ownerId: String(ownerId || activeHost.ownerId || "").trim(),
-      ownerName: String(ownerName || activeHost.ownerName || "").trim(),
-      provider: String(provider || activeHost.provider || "").trim(),
-      model: String(model || activeHost.model || "").trim(),
-      runtimeProfile: String(runtimeProfile || activeHost.runtimeProfile || "").trim(),
-      updatedAt: new Date().toISOString()
-    };
+  let latestHost = null;
+  for (const serviceId of bridgeServicesForLiveTui()) {
+    const bridge = await loadGatewayBridge(serviceId);
+    const activeHost = bridge.activeHost || {};
+    if (Number(activeHost.pid || 0) !== process.pid) {
+      bridge.activeHost = createTelegramBridgeHostRecord({ sessionId, cwd, label, surface, ownerId, ownerName, provider, model, runtimeProfile });
+    } else {
+      bridge.activeHost = {
+        ...activeHost,
+        sessionId: String(sessionId || "").trim(),
+        cwd: String(cwd || "").trim(),
+        label: String(label || activeHost.label || "").trim(),
+        surface: String(surface || activeHost.surface || "live-tui").trim() || "live-tui",
+        ownerId: String(ownerId || activeHost.ownerId || "").trim(),
+        ownerName: String(ownerName || activeHost.ownerName || "").trim(),
+        provider: String(provider || activeHost.provider || "").trim(),
+        model: String(model || activeHost.model || "").trim(),
+        runtimeProfile: String(runtimeProfile || activeHost.runtimeProfile || "").trim(),
+        updatedAt: new Date().toISOString()
+      };
+    }
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+    await saveGatewayBridge(serviceId, bridge);
+    latestHost = bridge.activeHost;
   }
-  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
-  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
-  await syncSharedTelegramBridgeAgent({ cwd, host: bridge.activeHost, actor: actor || { id: ownerId, name: ownerName } });
-  return bridge.activeHost;
+  await syncSharedTelegramBridgeAgent({ cwd, host: latestHost || {}, actor: actor || { id: ownerId, name: ownerName } });
+  return latestHost;
 }
 
 async function clearTelegramBridgeHost() {
-  const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
-  if (Number(bridge.activeHost?.pid || 0) === process.pid) {
-    bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
+  for (const serviceId of bridgeServicesForLiveTui()) {
+    const bridge = await loadGatewayBridge(serviceId);
+    if (Number(bridge.activeHost?.pid || 0) === process.pid) {
+      bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
+    }
+    bridge.hosts = Array.isArray(bridge.hosts) ? bridge.hosts.filter((host) => Number(host?.pid || 0) !== process.pid) : [];
+    await saveGatewayBridge(serviceId, bridge);
   }
-  bridge.hosts = Array.isArray(bridge.hosts) ? bridge.hosts.filter((host) => Number(host?.pid || 0) !== process.pid) : [];
-  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
 }
 
 async function dequeueTelegramBridgeRequest({ cwd }) {
-  const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
+  for (const serviceId of bridgeServicesForLiveTui()) {
+    const next = await dequeueBridgeRequestForService(serviceId, { cwd });
+    if (next) return next;
+  }
+  return null;
+}
+
+async function dequeueBridgeRequestForService(serviceId, { cwd }) {
+  const bridge = await loadGatewayBridge(serviceId);
   const activeHost = bridge.activeHost || {};
   const currentHost = Number(activeHost.pid || 0) === process.pid
     ? activeHost
@@ -3156,12 +3178,13 @@ async function dequeueTelegramBridgeRequest({ cwd }) {
     };
     bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   }
-  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
+  await saveGatewayBridge(serviceId, bridge);
   return next;
 }
 
 async function deliverTelegramBridgeReply(request, { sessionId, content = "", error = "", meta = {} }) {
-  const bridge = await loadGatewayBridge(TELEGRAM_BRIDGE_SERVICE);
+  const serviceId = String(request?.source || TELEGRAM_BRIDGE_SERVICE).trim().toLowerCase() || TELEGRAM_BRIDGE_SERVICE;
+  const bridge = await loadGatewayBridge(serviceId);
   const replies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies : [];
   replies.push({
     requestId: String(request?.id || "").trim(),
@@ -3184,7 +3207,7 @@ async function deliverTelegramBridgeReply(request, { sessionId, content = "", er
   if (Number(bridge.activeHost?.pid || 0) === process.pid) {
     bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   }
-  await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
+  await saveGatewayBridge(serviceId, bridge);
 }
 
 function formatTelegramRemoteActor(request = {}) {

package/src/discord.js

@@ -1,9 +1,12 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { loadGatewayBridge, saveGatewayBridge } 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 INTENT_BITS = {
   GUILDS: 1 << 0,
@@ -113,18 +116,128 @@ function shouldReplyToMessage(message, botUserId) {
 
 function buildReply(message, botUserId) {
   const content = extractMentionContent(message.content, botUserId).toLowerCase();
+  const normalized = content.replace(/\s+/g, " ").trim();
   if (!content || content === "ping") {
     return "pong";
   }
-  if (content.includes("status") || content.includes("online")) {
+  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 (content.includes("hello") || content.includes("hi") || content.includes("hey")) {
+  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 createBridgeRequestId() {
+  return `dc_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function describeDiscordUser(message = {}) {
+  const author = message?.author || {};
+  const username = String(author.username || "").trim();
+  const globalName = String(author.global_name || "").trim();
+  const displayName = globalName || username || String(author.id || "").trim() || "discord";
+  return {
+    userId: String(author.id || "").trim(),
+    username,
+    displayName
+  };
+}
+
+async function getLiveBridgeHost({ 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;
+    }
+    if (cwd && host.cwd && String(host.cwd) !== String(cwd || "")) {
+      continue;
+    }
+    nextHosts.push(host);
+  }
+  if (changed || nextHosts.length !== hosts.length) {
+    bridge.hosts = nextHosts;
+    const activePid = Number(bridge.activeHost?.pid || 0);
+    if (activePid > 0 && !nextHosts.some((host) => Number(host?.pid || 0) === activePid)) {
+      bridge.activeHost = { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" };
+    }
+    await saveGatewayBridge("discord", bridge);
+  }
+  return bridge.activeHost?.pid ? bridge.activeHost : (nextHosts[0] || null);
+}
+
+async function runPromptViaBridge(runtime, message, promptText) {
+  const host = await getLiveBridgeHost();
+  if (!host) {
+    return { error: "No live Waterbrother TUI is connected. Start Waterbrother in the terminal first, then retry." };
+  }
+
+  const requestId = createBridgeRequestId();
+  const actor = describeDiscordUser(message);
+  const bridge = await loadGatewayBridge("discord");
+  const requests = Array.isArray(bridge.pendingRequests) ? bridge.pendingRequests : [];
+  requests.push({
+    id: requestId,
+    chatId: String(message.channel_id || "").trim(),
+    userId: actor.userId,
+    username: actor.username,
+    usernameHandle: actor.username ? `@${actor.username}` : "",
+    displayName: actor.displayName,
+    sessionId: "",
+    text: String(promptText || "").trim(),
+    requestKind: "prompt",
+    explicitExecution: true,
+    targetPid: Number(host?.pid || 0),
+    targetSessionId: String(host?.sessionId || "").trim(),
+    targetOwnerId: String(host?.ownerId || "").trim(),
+    runtimeProfile: "",
+    replyToMessageId: 0,
+    requestedAt: new Date().toISOString(),
+    status: "pending",
+    source: "discord"
+  });
+  bridge.pendingRequests = requests.slice(-100);
+  bridge.deliveredReplies = Array.isArray(bridge.deliveredReplies) ? bridge.deliveredReplies : [];
+  await saveGatewayBridge("discord", bridge);
+
+  const deadline = Date.now() + DISCORD_BRIDGE_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((resolve) => setTimeout(resolve, DISCORD_BRIDGE_POLL_MS));
+    const nextBridge = await loadGatewayBridge("discord");
+    const replyIndex = Array.isArray(nextBridge.deliveredReplies)
+      ? nextBridge.deliveredReplies.findIndex((item) => item?.requestId === requestId)
+      : -1;
+    if (replyIndex >= 0) {
+      const reply = nextBridge.deliveredReplies[replyIndex];
+      nextBridge.deliveredReplies.splice(replyIndex, 1);
+      await saveGatewayBridge("discord", nextBridge);
+      if (reply.error) {
+        return { error: String(reply.error || "").trim() || "Discord bridge execution failed." };
+      }
+      return { content: String(reply.content || "").trim() || "(no content)" };
+    }
+  }
+
+  const finalBridge = await loadGatewayBridge("discord");
+  finalBridge.pendingRequests = Array.isArray(finalBridge.pendingRequests)
+    ? finalBridge.pendingRequests.filter((item) => item?.id !== requestId)
+    : [];
+  await saveGatewayBridge("discord", finalBridge);
+  return { error: "Discord bridge timed out waiting for the live terminal." };
+}
+
 export async function getDiscordStatus(runtime = {}) {
   const discord = normalizeDiscordRuntime(runtime);
   const saved = await loadDiscordStatus();
@@ -259,16 +372,27 @@ 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()}`);
-        if (shouldReplyToMessage(msg, botUser?.id)) {
-          const reply = buildReply(msg, botUser?.id);
+        const reply = shouldReplyToMessage(msg, botUser?.id)
+          ? buildReply(msg, botUser?.id)
+          : null;
+        try {
           if (reply) {
-            try {
-              await sendChannelMessage(discord, msg.channel_id, reply);
-              log(`discord: replied in ${msg.channel_id}`);
-            } catch (error) {
-              log(`discord: reply failed: ${error instanceof Error ? error.message : String(error)}`);
+            await sendChannelMessage(discord, msg.channel_id, reply);
+            log(`discord: replied in ${msg.channel_id}`);
+            return;
+          }
+          if (!msg.guild_id) {
+            const bridged = await runPromptViaBridge(runtime, msg, String(msg.content || "").trim());
+            if (bridged?.content) {
+              await sendChannelMessage(discord, msg.channel_id, bridged.content);
+              log(`discord: bridged reply in ${msg.channel_id}`);
+            } else if (bridged?.error) {
+              await sendChannelMessage(discord, msg.channel_id, bridged.error);
+              log(`discord: bridge error in ${msg.channel_id}`);
             }
           }
+        } catch (error) {
+          log(`discord: reply failed: ${error instanceof Error ? error.message : String(error)}`);
         }
       }
     });