@tritard/waterbrother 0.16.143 → 0.16.144

package/package.json

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

package/src/channels.js

@@ -232,11 +232,12 @@ export function buildChannelOnboardingPayload(serviceId) {
         "waterbrother config set-json channels '{\"discord\":{\"enabled\":true,\"botToken\":\"YOUR_BOT_TOKEN\",\"applicationId\":\"YOUR_APP_ID\",\"pairingMode\":\"manual\",\"allowedUserIds\":[]}}'",
         "waterbrother channels status",
         "waterbrother discord status",
+        "waterbrother discord sync-commands",
         "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.",
+        "Waterbrother now syncs native Discord slash commands on startup, and you can force a sync with waterbrother discord sync-commands.",
         "Prefer explicit user allowlists.",
         "The interactive TUI onboarding wizard can store the Discord token and application id directly, just like Telegram."
       ]

package/src/cli.js

@@ -8,7 +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 { getDiscordStatus, runDiscordGateway, syncDiscordCommands } from "./discord.js";
 import { createChatCompletion, createJsonCompletion, listModels } from "./model-client.js";
 import { buildChannelOnboardingPayload, getChannelStatuses, getGatewayStatus } from "./channels.js";
 import { runGatewayService } from "./gateway.js";
@@ -4226,8 +4226,8 @@ async function runDoctorCommand({ runtime, cwd, asJson = false }) {
 
 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 (!["status", "run", "sync-commands"].includes(sub)) {
+    throw new Error("Usage: waterbrother discord <status|run|sync-commands>");
   }
 
   if (sub === "status") {
@@ -4243,6 +4243,12 @@ async function runDiscordCommand(positional, runtime, { asJson = false } = {}) {
     console.log(`token: ${status.tokenConfigured ? "configured" : "missing"}`);
     console.log(`application id: ${status.applicationId || "missing"}`);
     console.log(`intents: ${status.intents.join(", ") || "none"}`);
+    if (status.commandScope) {
+      console.log(`slash commands: ${status.commandCount || 0} (${status.commandScope})`);
+      if (status.commandUpdatedAt) {
+        console.log(`commands updated: ${status.commandUpdatedAt}`);
+      }
+    }
     if (status.lastStatus) {
       console.log(`last state: ${status.lastStatus.state || "unknown"}`);
       console.log(`updated: ${status.lastStatus.updatedAt || "unknown"}`);
@@ -4253,6 +4259,20 @@ async function runDiscordCommand(positional, runtime, { asJson = false } = {}) {
     return;
   }
 
+  if (sub === "sync-commands") {
+    if (asJson) {
+      const result = await syncDiscordCommands(runtime);
+      printData(result, true);
+      return;
+    }
+    const result = await syncDiscordCommands(runtime, { log: (line) => console.log(line) });
+    console.log("Discord slash commands");
+    console.log("");
+    console.log(`scope: ${result.scope}`);
+    console.log(`count: ${result.count}`);
+    return;
+  }
+
   if (asJson) {
     throw new Error("waterbrother discord run does not support --json");
   }

package/src/discord.js

@@ -35,6 +35,7 @@ const STATUS_PATH = path.join(os.homedir(), ".waterbrother", "discord-status.jso
 const DISCORD_BRIDGE_TIMEOUT_MS = 5 * 60 * 1000;
 const DISCORD_BRIDGE_POLL_MS = 250;
 const DISCORD_CONTINUATION_TTL_MS = 15 * 60 * 1000;
+const DISCORD_COMMAND_VERSION = 1;
 
 const INTENT_BITS = {
   GUILDS: 1 << 0,
@@ -77,6 +78,14 @@ async function loadDiscordStatus() {
   }
 }
 
+async function patchDiscordStatus(patch = {}) {
+  const current = await loadDiscordStatus().catch(() => null);
+  await saveDiscordStatus({
+    ...(current || {}),
+    ...patch
+  });
+}
+
 function normalizeDiscordRuntime(runtime = {}) {
   const discord = runtime?.channels?.discord || {};
   const intents = Array.isArray(discord.intents) && discord.intents.length > 0
@@ -93,6 +102,169 @@ function normalizeDiscordRuntime(runtime = {}) {
   };
 }
 
+function buildDiscordSlashCommands() {
+  const roleChoices = [
+    { name: "executor", value: "executor" },
+    { name: "reviewer", value: "reviewer" },
+    { name: "verifier", value: "verifier" },
+    { name: "standby", value: "standby" }
+  ];
+  const roomModeChoices = [
+    { name: "chat", value: "chat" },
+    { name: "plan", value: "plan" },
+    { name: "execute", value: "execute" }
+  ];
+  const taskStateChoices = [
+    { name: "open", value: "open" },
+    { name: "active", value: "active" },
+    { name: "blocked", value: "blocked" },
+    { name: "done", value: "done" }
+  ];
+  const inviteRoleChoices = [
+    { name: "owner", value: "owner" },
+    { name: "editor", value: "editor" },
+    { name: "observer", value: "observer" }
+  ];
+  const commands = [
+    { name: "help", description: "Show Waterbrother Discord help" },
+    { name: "about", description: "Show Waterbrother identity and capabilities" },
+    { name: "state", description: "Show Waterbrother self-awareness state" },
+    { name: "status", description: "Show Discord gateway and remote session status" },
+    { name: "project", description: "Show the current project and sharing state" },
+    { name: "project-share", description: "Share the current project with this Discord room" },
+    { name: "room", description: "Show shared room status for this project" },
+    { name: "members", description: "List shared room members" },
+    { name: "tasks", description: "List shared tasks" },
+    { name: "people", description: "List recently seen Discord people" },
+    { name: "terminals", description: "List live Waterbrother terminals" },
+    { name: "executor", description: "Show the assigned executor" },
+    { name: "reviewer", description: "Show the assigned reviewer" },
+    { name: "verifier", description: "Show the assigned verifier" },
+    { name: "verify", description: "Run verification through the assigned verifier" },
+    { name: "verification", description: "Show the latest verification result" },
+    { name: "rerun-verification", description: "Rerun verification" },
+    { name: "override-verification", description: "Override blocking verification" },
+    { name: "review-status", description: "Show reviewer blocking status and latest outcome" },
+    { name: "accept-reviewer-concerns", description: "Accept reviewer concerns and clear blocking review" },
+    { name: "override-reviewer", description: "Override the current reviewer outcome" },
+    { name: "switch-executor-to-reviewer", description: "Make the reviewer the executor" },
+    { name: "new", description: "Start a fresh remote session" },
+    { name: "sessions", description: "List recent remote sessions" },
+    { name: "clear", description: "Clear the current remote conversation" },
+    {
+      name: "resume",
+      description: "Resume a remote session",
+      options: [
+        { type: 3, name: "session-id", description: "Remote session id", required: true }
+      ]
+    },
+    {
+      name: "mode",
+      description: "Show or set the shared room mode",
+      options: [
+        { type: 3, name: "mode", description: "Room mode", required: false, choices: roomModeChoices }
+      ]
+    },
+    { name: "events", description: "List recent shared room events" },
+    { name: "invites", description: "List pending shared room invites" },
+    {
+      name: "invite",
+      description: "Create a shared room invite",
+      options: [
+        { type: 3, name: "target", description: "Discord user id, @username, or recent display name", required: true },
+        { type: 3, name: "role", description: "Invite role", required: false, choices: inviteRoleChoices }
+      ]
+    },
+    {
+      name: "approve-invite",
+      description: "Approve a pending invite",
+      options: [
+        { type: 3, name: "invite-id", description: "Invite id", required: true }
+      ]
+    },
+    {
+      name: "accept-invite",
+      description: "Accept a pending invite",
+      options: [
+        { type: 3, name: "invite-id", description: "Invite id", required: true }
+      ]
+    },
+    {
+      name: "reject-invite",
+      description: "Reject a pending invite",
+      options: [
+        { type: 3, name: "invite-id", description: "Invite id", required: true }
+      ]
+    },
+    {
+      name: "remove-member",
+      description: "Remove a shared room member",
+      options: [
+        { type: 3, name: "member-id", description: "Member id", required: true }
+      ]
+    },
+    { name: "claim", description: "Claim shared operator control" },
+    { name: "release", description: "Release shared operator control" },
+    {
+      name: "assign-role",
+      description: "Assign a room role to a terminal or agent",
+      options: [
+        { type: 3, name: "target", description: "Terminal label, this terminal, or agent label", required: true },
+        { type: 3, name: "role", description: "Role to assign", required: true, choices: roleChoices }
+      ]
+    },
+    {
+      name: "task-add",
+      description: "Add a shared task",
+      options: [
+        { type: 3, name: "text", description: "Task text", required: true }
+      ]
+    },
+    {
+      name: "task-move",
+      description: "Move a shared task",
+      options: [
+        { type: 3, name: "task-id", description: "Task id", required: true },
+        { type: 3, name: "state", description: "Next task state", required: true, choices: taskStateChoices }
+      ]
+    },
+    {
+      name: "task-assign",
+      description: "Assign a shared task",
+      options: [
+        { type: 3, name: "task-id", description: "Task id", required: true },
+        { type: 3, name: "member-id", description: "Member id", required: true }
+      ]
+    },
+    {
+      name: "task-claim",
+      description: "Claim a shared task",
+      options: [
+        { type: 3, name: "task-id", description: "Task id", required: true }
+      ]
+    },
+    {
+      name: "task-comment",
+      description: "Comment on a shared task",
+      options: [
+        { type: 3, name: "task-id", description: "Task id", required: true },
+        { type: 3, name: "text", description: "Comment text", required: true }
+      ]
+    },
+    {
+      name: "task-history",
+      description: "Show shared task history",
+      options: [
+        { type: 3, name: "task-id", description: "Task id", required: true }
+      ]
+    }
+  ];
+  return commands.map((command) => ({
+    ...command,
+    dm_permission: true
+  }));
+}
+
 async function discordFetch(runtime, route, init = {}) {
   const token = String(runtime?.token || "").trim();
   if (!token) {
@@ -112,6 +284,55 @@ async function discordFetch(runtime, route, init = {}) {
   return response.json();
 }
 
+function getDiscordCommandScope(discord = {}, status = null) {
+  const guildId = String(discord.guildId || status?.lastGuildId || "").trim();
+  if (guildId) {
+    return {
+      guildId,
+      scope: `guild:${guildId}`,
+      route: `/applications/${discord.applicationId}/guilds/${guildId}/commands`
+    };
+  }
+  return {
+    guildId: "",
+    scope: "global",
+    route: `/applications/${discord.applicationId}/commands`
+  };
+}
+
+export async function syncDiscordCommands(runtime = {}, { log = () => {} } = {}) {
+  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 savedStatus = await loadDiscordStatus().catch(() => null);
+  const scope = getDiscordCommandScope(discord, savedStatus);
+  const commands = buildDiscordSlashCommands();
+  const synced = await discordFetch(discord, scope.route, {
+    method: "PUT",
+    body: JSON.stringify(commands)
+  });
+  const count = Array.isArray(synced) ? synced.length : commands.length;
+  await patchDiscordStatus({
+    commandVersion: DISCORD_COMMAND_VERSION,
+    commandScope: scope.scope,
+    commandCount: count,
+    commandUpdatedAt: new Date().toISOString()
+  });
+  log(`discord: slash commands synced (${scope.scope}, ${count})`);
+  return {
+    scope: scope.scope,
+    guildId: scope.guildId,
+    count
+  };
+}
+
 async function fetchGatewayInfo(runtime) {
   return discordFetch(runtime, "/gateway/bot", { method: "GET" });
 }
@@ -125,6 +346,27 @@ async function sendChannelMessage(runtime, channelId, content) {
   });
 }
 
+async function createInteractionResponse(runtime, interaction, body) {
+  return discordFetch(runtime, `/interactions/${interaction.id}/${interaction.token}/callback`, {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+}
+
+async function deferInteractionResponse(runtime, interaction) {
+  return createInteractionResponse(runtime, interaction, {
+    type: 5
+  });
+}
+
+async function editInteractionResponse(runtime, interaction, content) {
+  const text = String(content || "").trim() || "(no content)";
+  return discordFetch(runtime, `/webhooks/${runtime.applicationId}/${interaction.token}/messages/@original`, {
+    method: "PATCH",
+    body: JSON.stringify({ content: text })
+  });
+}
+
 function extractMentionContent(content, botUserId) {
   const raw = String(content || "");
   if (!botUserId) return raw.trim();
@@ -348,6 +590,105 @@ function describeDiscordUser(message = {}) {
   };
 }
 
+function getInteractionOptionValue(options = [], name) {
+  const match = Array.isArray(options) ? options.find((option) => String(option?.name || "").trim() === String(name || "").trim()) : null;
+  return match?.value;
+}
+
+function buildInteractionMessage(interaction = {}) {
+  const user = interaction?.member?.user || interaction?.user || {};
+  return {
+    id: String(interaction?.id || "").trim(),
+    channel_id: String(interaction?.channel_id || "").trim(),
+    guild_id: String(interaction?.guild_id || "").trim(),
+    content: "",
+    author: {
+      id: String(user?.id || "").trim(),
+      username: String(user?.username || "").trim(),
+      global_name: String(user?.global_name || "").trim(),
+      bot: Boolean(user?.bot)
+    },
+    mentions: []
+  };
+}
+
+function buildDiscordCommandTextFromInteraction(interaction = {}) {
+  const data = interaction?.data && typeof interaction.data === "object" ? interaction.data : {};
+  const name = String(data.name || "").trim().toLowerCase();
+  const options = Array.isArray(data.options) ? data.options : [];
+  switch (name) {
+    case "help":
+    case "about":
+    case "state":
+    case "status":
+    case "project":
+    case "room":
+    case "members":
+    case "tasks":
+    case "people":
+    case "terminals":
+    case "executor":
+    case "reviewer":
+    case "verifier":
+    case "verify":
+    case "verification":
+    case "rerun-verification":
+    case "override-verification":
+    case "review-status":
+    case "accept-reviewer-concerns":
+    case "override-reviewer":
+    case "switch-executor-to-reviewer":
+    case "new":
+    case "sessions":
+    case "clear":
+    case "events":
+    case "invites":
+    case "claim":
+    case "release":
+      return `/${name}`;
+    case "project-share":
+      return "/project share";
+    case "resume":
+      return `/resume ${String(getInteractionOptionValue(options, "session-id") || "").trim()}`.trim();
+    case "mode": {
+      const mode = String(getInteractionOptionValue(options, "mode") || "").trim();
+      return mode ? `/mode ${mode}` : "/mode";
+    }
+    case "invite": {
+      const target = String(getInteractionOptionValue(options, "target") || "").trim();
+      const role = String(getInteractionOptionValue(options, "role") || "").trim();
+      return [`/invite`, target, role].filter(Boolean).join(" ");
+    }
+    case "approve-invite":
+      return `/approve-invite ${String(getInteractionOptionValue(options, "invite-id") || "").trim()}`.trim();
+    case "accept-invite":
+      return `/accept-invite ${String(getInteractionOptionValue(options, "invite-id") || "").trim()}`.trim();
+    case "reject-invite":
+      return `/reject-invite ${String(getInteractionOptionValue(options, "invite-id") || "").trim()}`.trim();
+    case "remove-member":
+      return `/remove-member ${String(getInteractionOptionValue(options, "member-id") || "").trim()}`.trim();
+    case "assign-role": {
+      const target = String(getInteractionOptionValue(options, "target") || "").trim();
+      const role = String(getInteractionOptionValue(options, "role") || "").trim();
+      return [`/assign-role`, target, role].filter(Boolean).join(" ");
+    }
+    case "task-add":
+      return `/task add ${String(getInteractionOptionValue(options, "text") || "").trim()}`.trim();
+    case "task-move":
+      return `/task move ${String(getInteractionOptionValue(options, "task-id") || "").trim()} ${String(getInteractionOptionValue(options, "state") || "").trim()}`.trim();
+    case "task-assign":
+      return `/task assign ${String(getInteractionOptionValue(options, "task-id") || "").trim()} ${String(getInteractionOptionValue(options, "member-id") || "").trim()}`.trim();
+    case "task-claim":
+      return `/task claim ${String(getInteractionOptionValue(options, "task-id") || "").trim()}`.trim();
+    case "task-comment":
+      return `/task comment ${String(getInteractionOptionValue(options, "task-id") || "").trim()} ${String(getInteractionOptionValue(options, "text") || "").trim()}`.trim();
+    case "task-history":
+      return `/task history ${String(getInteractionOptionValue(options, "task-id") || "").trim()}`.trim();
+    default:
+      return "";
+  }
+}
+
 function formatDiscordInvites(invites = []) {
   if (!invites.length) return "Pending invites\n- none";
   return [
@@ -976,6 +1317,37 @@ async function handleDiscordSessionCommand(runtime, state, message, command) {
   return null;
 }
 
+async function handleDiscordSlashInteraction(runtime, interaction, { log = () => {} } = {}) {
+  const discord = normalizeDiscordRuntime(runtime);
+  const message = buildInteractionMessage(interaction);
+  const rawText = buildDiscordCommandTextFromInteraction(interaction);
+  if (!rawText) {
+    await createInteractionResponse(discord, interaction, {
+      type: 4,
+      data: { content: "Unsupported slash command payload." }
+    });
+    return;
+  }
+
+  await deferInteractionResponse(discord, interaction);
+  try {
+    const state = await loadDiscordGatewayState();
+    let reply = await handleDiscordControlCommand(runtime, state, message, rawText);
+    if (!reply) {
+      const command = parseDiscordSessionCommand(rawText);
+      if (command) {
+        reply = await handleDiscordSessionCommand(runtime, state, message, command);
+      }
+    }
+    await editInteractionResponse(discord, interaction, reply || "Command completed.");
+    log(`discord: interaction reply in ${message.channel_id}`);
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    await editInteractionResponse(discord, interaction, `Slash command failed: ${text}`);
+    throw error;
+  }
+}
+
 async function buildDiscordAbout(runtime, state, message) {
   const actor = describeDiscordUser(message);
   const sessionId = getPeerState(state, actor.userId)?.sessionId || "";
@@ -1807,6 +2179,9 @@ export async function getDiscordStatus(runtime = {}) {
     guildId: discord.guildId || null,
     intents: discord.intents,
     intentMask: discord.intentMask,
+    commandScope: saved?.commandScope || null,
+    commandCount: Number(saved?.commandCount || 0),
+    commandUpdatedAt: saved?.commandUpdatedAt || null,
     lastStatus: saved
   };
 }
@@ -1823,6 +2198,12 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
     throw new Error("Discord application id is missing");
   }
 
+  try {
+    await syncDiscordCommands(runtime, { log });
+  } catch (error) {
+    log(`discord: slash command sync failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+
   const gatewayInfo = await fetchGatewayInfo(discord);
   const gatewayUrl = `${gatewayInfo.url}?v=10&encoding=json`;
   const ws = new WebSocket(gatewayUrl);
@@ -1843,7 +2224,7 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
     closed = true;
     stopHeartbeat();
     try { ws.close(1000, reason); } catch {}
-    await saveDiscordStatus({
+    await patchDiscordStatus({
       state: reason,
       updatedAt: new Date().toISOString(),
       applicationId: discord.applicationId,
@@ -1911,7 +2292,7 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
       if (packet.t === "READY") {
         botUser = packet.d?.user || null;
         log(`discord: ready as ${botUser?.username || "unknown"} (${botUser?.id || "n/a"})`);
-        void saveDiscordStatus({
+        void patchDiscordStatus({
           state: "ready",
           updatedAt: new Date().toISOString(),
           applicationId: discord.applicationId,
@@ -1923,12 +2304,33 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
         return;
       }
 
+      if (packet.t === "INTERACTION_CREATE") {
+        try {
+          if (packet.d?.guild_id) {
+            await patchDiscordStatus({
+              lastGuildId: String(packet.d.guild_id || "").trim(),
+              updatedAt: new Date().toISOString()
+            });
+          }
+          await handleDiscordSlashInteraction(runtime, packet.d, { log });
+        } catch (error) {
+          log(`discord: interaction failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        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()}`);
         try {
+          if (msg.guild_id) {
+            await patchDiscordStatus({
+              lastGuildId: String(msg.guild_id || "").trim(),
+              updatedAt: new Date().toISOString()
+            });
+          }
           const trackingState = await loadDiscordGatewayState();
           await rememberKnownDiscordPeople(trackingState, msg);
           const shouldReply = shouldReplyToMessage(msg, botUser?.id);