@tritard/waterbrother 0.16.121 → 0.16.123

package/package.json

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

package/src/channels.js

@@ -55,7 +55,13 @@ function normalizeTelegramConfig(value = {}) {
   const common = normalizeCommonChannelConfig(source);
   return {
     ...common,
-    botToken: String(source.botToken || "").trim(),
+    botToken: String(
+      source.botToken ||
+      source.token ||
+      process.env.TELEGRAM_BOT_TOKEN ||
+      process.env.WATERBROTHER_TELEGRAM_BOT_TOKEN ||
+      ""
+    ).trim(),
     pairingExpiryMinutes: Number.isFinite(Number(source.pairingExpiryMinutes)) ? Math.max(1, Math.floor(Number(source.pairingExpiryMinutes))) : 720
   };
 }
@@ -65,8 +71,19 @@ function normalizeDiscordConfig(value = {}) {
   const common = normalizeCommonChannelConfig(source);
   return {
     ...common,
-    botToken: String(source.botToken || "").trim(),
-    applicationId: String(source.applicationId || "").trim(),
+    botToken: String(
+      source.botToken ||
+      source.token ||
+      process.env.DISCORD_BOT_TOKEN ||
+      process.env.WATERBROTHER_DISCORD_BOT_TOKEN ||
+      ""
+    ).trim(),
+    applicationId: String(
+      source.applicationId ||
+      process.env.DISCORD_APPLICATION_ID ||
+      process.env.WATERBROTHER_DISCORD_APPLICATION_ID ||
+      ""
+    ).trim(),
     allowedGuildIds: asStringArray(source.allowedGuildIds)
   };
 }
@@ -205,19 +222,21 @@ export function buildChannelOnboardingPayload(serviceId) {
       id: spec.id,
       label: spec.label,
       docsPath: spec.docsPath,
-      summary: "Single-user Discord control through a bot token, application id, and DM-first policy.",
+      summary: "DM-first Discord control through a bot token, application id, and a local Gateway runner.",
       prerequisites: [
         "Create a Discord application and bot",
         "Capture the bot token and application id",
-        "Enable only the intents you actually need"
+        "Enable Message Content Intent before testing DMs or mentions"
       ],
       commands: [
-        "waterbrother config set-json channels '{\"discord\":{\"enabled\":true,\"botToken\":\"YOUR_BOT_TOKEN\",\"applicationId\":\"YOUR_APP_ID\",\"pairingMode\":\"manual\",\"allowedUserIds\":[]}}'",
+        "waterbrother config set-json channels '{\"discord\":{\"enabled\":true,\"botToken\":\"{env:DISCORD_BOT_TOKEN}\",\"applicationId\":\"{env:DISCORD_APPLICATION_ID}\",\"pairingMode\":\"manual\",\"allowedUserIds\":[]}}'",
         "waterbrother channels status",
-        "waterbrother gateway status"
+        "waterbrother discord status",
+        "waterbrother discord run"
       ],
       notes: [
         "Start with direct messages before any guild or channel workflow.",
+        "This first runtime slice handles DMs and mentions, not full Roundtable rooms yet.",
         "Prefer explicit user allowlists."
       ]
     };

package/src/cli.js

@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 import { Agent } from "./agent.js";
 import { getConfigPath, loadConfigLayers, resolveRuntimeConfig, saveConfig } from "./config.js";
+import { getDiscordStatus, runDiscordGateway } from "./discord.js";
 import { createChatCompletion, createJsonCompletion, listModels } from "./model-client.js";
 import { buildChannelOnboardingPayload, getChannelStatuses, getGatewayStatus } from "./channels.js";
 import { runGatewayService } from "./gateway.js";
@@ -334,6 +335,8 @@ Usage:
   waterbrother channels list
   waterbrother channels status
   waterbrother channels show <service>
+  waterbrother discord status
+  waterbrother discord run
   waterbrother gateway status
   waterbrother gateway run telegram
   waterbrother gateway stop [telegram]
@@ -3854,6 +3857,7 @@ async function runDoctorCommand({ runtime, cwd, asJson = false }) {
   const git = await checkBinary("git");
   const mcpServerNames = Object.keys(runtime.mcpServers || {});
   const gateway = getGatewayStatus(runtime);
+  const discord = await getDiscordStatus(runtime);
 
   const report = {
     timestamp: new Date().toISOString(),
@@ -3878,6 +3882,15 @@ async function runDoctorCommand({ runtime, cwd, asJson = false }) {
       gateway,
       channels: gateway.channels
     },
+    discord: {
+      configured: discord.configured,
+      enabled: discord.enabled,
+      tokenConfigured: discord.tokenConfigured,
+      applicationId: discord.applicationId,
+      intents: discord.intents,
+      state: discord.lastStatus?.state || null,
+      botUser: discord.lastStatus?.botUser || null
+    },
     binaries: {
       rg,
       git
@@ -3902,10 +3915,50 @@ async function runDoctorCommand({ runtime, cwd, asJson = false }) {
   for (const channel of gateway.channels) {
     console.log(`  - ${formatChannelStatusLine(channel)}`);
   }
+  console.log(`Discord runtime: ${report.discord.configured ? `configured (${report.discord.state || "idle"})` : "not configured"}`);
   console.log(`rg: ${rg.ok ? `ok (${rg.path})` : "missing"}`);
   console.log(`git: ${git.ok ? `ok (${git.path})` : "missing"}`);
 }
 
+async function runDiscordCommand(positional, runtime, { asJson = false } = {}) {
+  const sub = String(positional[1] || "status").trim().toLowerCase();
+  if (!["status", "run"].includes(sub)) {
+    throw new Error("Usage: waterbrother discord <status|run>");
+  }
+
+  if (sub === "status") {
+    const status = await getDiscordStatus(runtime);
+    if (asJson) {
+      printData(status, true);
+      return;
+    }
+    console.log("Discord");
+    console.log("");
+    console.log(`configured: ${status.configured ? "yes" : "no"}`);
+    console.log(`enabled: ${status.enabled ? "yes" : "no"}`);
+    console.log(`token: ${status.tokenConfigured ? "configured" : "missing"}`);
+    console.log(`application id: ${status.applicationId || "missing"}`);
+    console.log(`intents: ${status.intents.join(", ") || "none"}`);
+    if (status.lastStatus) {
+      console.log(`last state: ${status.lastStatus.state || "unknown"}`);
+      console.log(`updated: ${status.lastStatus.updatedAt || "unknown"}`);
+      if (status.lastStatus.botUser?.username) {
+        console.log(`bot user: ${status.lastStatus.botUser.username}`);
+      }
+    }
+    return;
+  }
+
+  if (asJson) {
+    throw new Error("waterbrother discord run does not support --json");
+  }
+
+  console.log("Discord gateway");
+  console.log("");
+  console.log("Connecting to Discord Gateway. Press Ctrl+C to stop.");
+  await runDiscordGateway(runtime, { log: (line) => console.log(line) });
+}
+
 async function runChannelsCommand(positional, runtime, { asJson = false } = {}) {
   const sub = positional[1] || "status";
   const statuses = getChannelStatuses(runtime);
@@ -11228,6 +11281,11 @@ export async function runCli(argv) {
     return;
   }
 
+  if (command === "discord") {
+    await runDiscordCommand(positional, runtime, { asJson });
+    return;
+  }
+
   if (command === "update") {
     await runUpdateCommand({ cwd: startupCwd, asJson });
     return;

package/src/config.js

@@ -91,7 +91,7 @@ function readFirstEnv(names = []) {
 async function readJsonFile(filePath) {
   try {
     const raw = await fs.readFile(filePath, 'utf8');
-    return JSON.parse(raw);
+    return substituteEnvPlaceholders(JSON.parse(raw));
   } catch (error) {
     if (error && typeof error === 'object' && 'code' in error && error.code === 'ENOENT') {
       return {};
@@ -100,6 +100,19 @@ async function readJsonFile(filePath) {
   }
 }
 
+function substituteEnvPlaceholders(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => substituteEnvPlaceholders(item));
+  }
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [key, substituteEnvPlaceholders(entry)])
+    );
+  }
+  if (typeof value !== 'string') return value;
+  return value.replace(/\{env:([^}]+)\}/g, (_, key) => process.env[String(key).trim()] || '');
+}
+
 function mergeConfigLayers(userConfig = {}, projectConfig = {}) {
   const mergedMcpServers = {
     ...(userConfig.mcpServers && typeof userConfig.mcpServers === 'object' ? userConfig.mcpServers : {}),

package/src/discord.js

@@ -0,0 +1,290 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+const DISCORD_API_BASE = "https://discord.com/api/v10";
+const STATUS_PATH = path.join(os.homedir(), ".waterbrother", "discord-status.json");
+
+const INTENT_BITS = {
+  GUILDS: 1 << 0,
+  GUILD_MEMBERS: 1 << 1,
+  GUILD_MESSAGES: 1 << 9,
+  DIRECT_MESSAGES: 1 << 12,
+  MESSAGE_CONTENT: 1 << 15
+};
+
+function maskToken(token) {
+  const value = String(token || "").trim();
+  if (!value) return "";
+  if (value.length <= 10) return `${value.slice(0, 2)}...${value.slice(-2)}`;
+  return `${value.slice(0, 6)}...${value.slice(-4)}`;
+}
+
+function resolveIntentMask(intents = []) {
+  const names = Array.isArray(intents) ? intents : [];
+  return names.reduce((mask, name) => mask | (INTENT_BITS[String(name || "").trim()] || 0), 0);
+}
+
+async function ensureStatusDir() {
+  await fs.mkdir(path.dirname(STATUS_PATH), { recursive: true });
+}
+
+async function saveDiscordStatus(status) {
+  await ensureStatusDir();
+  await fs.writeFile(STATUS_PATH, `${JSON.stringify(status, null, 2)}\n`, "utf8");
+}
+
+async function loadDiscordStatus() {
+  try {
+    const raw = await fs.readFile(STATUS_PATH, "utf8");
+    return JSON.parse(raw);
+  } catch (error) {
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  }
+}
+
+function normalizeDiscordRuntime(runtime = {}) {
+  const discord = runtime?.channels?.discord || {};
+  const intents = Array.isArray(discord.intents) && discord.intents.length > 0
+    ? discord.intents
+    : ["GUILDS", "GUILD_MESSAGES", "DIRECT_MESSAGES", "MESSAGE_CONTENT"];
+  return {
+    enabled: discord.enabled === true,
+    token: String(discord.botToken || discord.token || "").trim(),
+    applicationId: String(discord.applicationId || "").trim(),
+    publicKey: String(discord.publicKey || "").trim(),
+    guildId: String(discord.guildId || "").trim(),
+    intents,
+    intentMask: resolveIntentMask(intents)
+  };
+}
+
+async function discordFetch(runtime, route, init = {}) {
+  const token = String(runtime?.token || "").trim();
+  if (!token) {
+    throw new Error("Discord bot token is missing");
+  }
+  const headers = {
+    "Content-Type": "application/json",
+    Authorization: `Bot ${token}`,
+    ...(init.headers || {})
+  };
+  const response = await fetch(`${DISCORD_API_BASE}${route}`, { ...init, headers });
+  if (!response.ok) {
+    const text = await response.text().catch(() => "");
+    throw new Error(`Discord API ${response.status}: ${text || response.statusText}`);
+  }
+  if (response.status === 204) return null;
+  return response.json();
+}
+
+async function fetchGatewayInfo(runtime) {
+  return discordFetch(runtime, "/gateway/bot", { method: "GET" });
+}
+
+async function sendChannelMessage(runtime, channelId, content) {
+  const text = String(content || "").trim();
+  if (!channelId || !text) return null;
+  return discordFetch(runtime, `/channels/${channelId}/messages`, {
+    method: "POST",
+    body: JSON.stringify({ content: text })
+  });
+}
+
+function extractMentionContent(content, botUserId) {
+  const raw = String(content || "");
+  if (!botUserId) return raw.trim();
+  return raw
+    .replace(new RegExp(`<@!?${botUserId}>`, "g"), "")
+    .trim();
+}
+
+function shouldReplyToMessage(message, botUserId) {
+  if (!message || message.author?.bot) return false;
+  const content = String(message.content || "").trim();
+  if (!content) return false;
+  const dm = !message.guild_id;
+  const mentioned = botUserId ? content.includes(`<@${botUserId}>`) || content.includes(`<@!${botUserId}>`) : false;
+  return dm || mentioned;
+}
+
+function buildReply(message, botUserId) {
+  const content = extractMentionContent(message.content, botUserId).toLowerCase();
+  if (!content || content === "ping") {
+    return "pong";
+  }
+  if (content.includes("status") || content.includes("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")) {
+    return "Waterbrother is here. Discord setup is live at the gateway level; deeper room workflows come next.";
+  }
+  return null;
+}
+
+export async function getDiscordStatus(runtime = {}) {
+  const discord = normalizeDiscordRuntime(runtime);
+  const saved = await loadDiscordStatus();
+  return {
+    configured: Boolean(discord.enabled && discord.token && discord.applicationId),
+    enabled: discord.enabled,
+    tokenConfigured: Boolean(discord.token),
+    tokenHint: discord.token ? maskToken(discord.token) : "",
+    applicationId: discord.applicationId || null,
+    publicKeyConfigured: Boolean(discord.publicKey),
+    guildId: discord.guildId || null,
+    intents: discord.intents,
+    intentMask: discord.intentMask,
+    lastStatus: saved
+  };
+}
+
+export async function runDiscordGateway(runtime = {}, { log = console.log, signal } = {}) {
+  const discord = normalizeDiscordRuntime(runtime);
+  if (!discord.enabled) {
+    throw new Error("Discord is not enabled in channels.discord.enabled");
+  }
+  if (!discord.token) {
+    throw new Error("Discord bot token is missing");
+  }
+  if (!discord.applicationId) {
+    throw new Error("Discord application id is missing");
+  }
+
+  const gatewayInfo = await fetchGatewayInfo(discord);
+  const gatewayUrl = `${gatewayInfo.url}?v=10&encoding=json`;
+  const ws = new WebSocket(gatewayUrl);
+
+  let heartbeatTimer = null;
+  let heartbeatAck = true;
+  let seq = null;
+  let botUser = null;
+  let closed = false;
+
+  const stopHeartbeat = () => {
+    if (heartbeatTimer) clearInterval(heartbeatTimer);
+    heartbeatTimer = null;
+  };
+
+  const close = async (reason = "shutdown") => {
+    if (closed) return;
+    closed = true;
+    stopHeartbeat();
+    try { ws.close(1000, reason); } catch {}
+    await saveDiscordStatus({
+      state: reason,
+      updatedAt: new Date().toISOString(),
+      applicationId: discord.applicationId,
+      tokenHint: maskToken(discord.token),
+      intents: discord.intents,
+      botUser: botUser ? { id: botUser.id, username: botUser.username } : null
+    });
+  };
+
+  if (signal) {
+    if (signal.aborted) {
+      await close("aborted");
+      return;
+    }
+    signal.addEventListener("abort", () => {
+      void close("aborted");
+    }, { once: true });
+  }
+
+  return new Promise((resolve, reject) => {
+    ws.addEventListener("message", async (event) => {
+      let packet;
+      try {
+        packet = JSON.parse(String(event.data || ""));
+      } catch {
+        return;
+      }
+      if (packet.s !== undefined && packet.s !== null) {
+        seq = packet.s;
+      }
+
+      if (packet.op === 10) {
+        const intervalMs = Number(packet.d?.heartbeat_interval || 45000);
+        heartbeatAck = true;
+        stopHeartbeat();
+        heartbeatTimer = setInterval(() => {
+          if (!heartbeatAck) {
+            log("discord: missed heartbeat ack, closing");
+            void close("heartbeat-timeout").then(resolve);
+            return;
+          }
+          heartbeatAck = false;
+          ws.send(JSON.stringify({ op: 1, d: seq }));
+        }, intervalMs);
+        ws.send(JSON.stringify({
+          op: 2,
+          d: {
+            token: discord.token,
+            intents: discord.intentMask,
+            properties: {
+              os: process.platform,
+              browser: "waterbrother",
+              device: "waterbrother"
+            }
+          }
+        }));
+        return;
+      }
+
+      if (packet.op === 11) {
+        heartbeatAck = true;
+        return;
+      }
+
+      if (packet.t === "READY") {
+        botUser = packet.d?.user || null;
+        log(`discord: ready as ${botUser?.username || "unknown"} (${botUser?.id || "n/a"})`);
+        void saveDiscordStatus({
+          state: "ready",
+          updatedAt: new Date().toISOString(),
+          applicationId: discord.applicationId,
+          tokenHint: maskToken(discord.token),
+          intents: discord.intents,
+          botUser: botUser ? { id: botUser.id, username: botUser.username } : null,
+          sessionId: packet.d?.session_id || null
+        });
+        return;
+      }
+
+      if (packet.t === "MESSAGE_CREATE") {
+        const msg = packet.d;
+        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);
+          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)}`);
+            }
+          }
+        }
+      }
+    });
+
+    ws.addEventListener("open", () => {
+      log("discord: gateway connected");
+    });
+
+    ws.addEventListener("close", async (event) => {
+      await close(`closed:${event.code}`);
+      resolve();
+    });
+
+    ws.addEventListener("error", async (event) => {
+      await close("error");
+      reject(new Error(`Discord gateway error: ${event?.message || "connection failed"}`));
+    });
+  });
+}