@tritard/waterbrother 0.16.128 → 0.16.131

package/package.json

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

package/src/cli.js

@@ -336,6 +336,10 @@ Usage:
   waterbrother channels list
   waterbrother channels status
   waterbrother channels show <service>
+  waterbrother ps
+  waterbrother up
+  waterbrother down
+  waterbrother restart
   waterbrother discord status
   waterbrother discord run
   waterbrother gateway status
@@ -3026,6 +3030,133 @@ async function stopTrackedGateway(service = "telegram", { io = console } = {}) {
   return { stopped, pid };
 }
 
+async function withTrackedGatewayProcess(service, command, runner) {
+  const normalized = String(service || "").trim().toLowerCase();
+  const processInfo = await loadGatewayProcessInfo(normalized);
+  if (isProcessAlive(processInfo.pid) && Number(processInfo.pid || 0) !== process.pid) {
+    throw new Error(`${normalized} is already running (pid ${processInfo.pid}). Use \`waterbrother down\`, \`waterbrother restart\`, or \`waterbrother gateway stop ${normalized}\` first.`);
+  }
+  await saveGatewayProcessInfo(normalized, {
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+    command
+  });
+  try {
+    return await runner();
+  } finally {
+    const current = await loadGatewayProcessInfo(normalized);
+    if (Number(current.pid || 0) === process.pid) {
+      await saveGatewayProcessInfo(normalized, { pid: 0, startedAt: "", command: "" });
+    }
+  }
+}
+
+async function getTrackedServiceStatus(service, runtime) {
+  const normalized = String(service || "").trim().toLowerCase();
+  const processInfo = await loadGatewayProcessInfo(normalized);
+  const bridge = await loadGatewayBridge(normalized);
+  const processAlive = isProcessAlive(processInfo.pid);
+  const activeHostPid = Number(bridge.activeHost?.pid || 0);
+  const liveHost = activeHostPid > 0 && isProcessAlive(activeHostPid) ? bridge.activeHost : null;
+  const channel = runtime?.channels?.[normalized] || {};
+  const configured = normalized === "telegram"
+    ? Boolean(channel.enabled && String(channel.botToken || "").trim())
+    : Boolean(channel.enabled && String(channel.botToken || "").trim() && String(channel.applicationId || "").trim());
+  return {
+    service: normalized,
+    configured,
+    running: processAlive,
+    pid: processAlive ? Number(processInfo.pid || 0) : 0,
+    command: processAlive ? String(processInfo.command || "").trim() : "",
+    liveHost: liveHost ? {
+      pid: Number(liveHost.pid || 0),
+      sessionId: String(liveHost.sessionId || "").trim(),
+      cwd: String(liveHost.cwd || "").trim(),
+      label: String(liveHost.label || "").trim(),
+      ownerName: String(liveHost.ownerName || "").trim()
+    } : null,
+    staleProcessInfo: Number(processInfo.pid || 0) > 0 && !processAlive
+  };
+}
+
+async function clearTrackedGatewayArtifacts(service) {
+  const normalized = String(service || "").trim().toLowerCase();
+  if (!["telegram", "discord"].includes(normalized)) return;
+  await saveGatewayProcessInfo(normalized, { pid: 0, startedAt: "", command: "" });
+}
+
+async function runProcessStatusCommand(runtime, { asJson = false } = {}) {
+  const services = await Promise.all(["telegram", "discord"].map((service) => getTrackedServiceStatus(service, runtime)));
+  if (asJson) {
+    printData({ services }, true);
+    return;
+  }
+  console.log("Waterbrother services");
+  console.log("");
+  for (const status of services) {
+    console.log(`${status.service}: ${status.running ? `running (pid ${status.pid})` : "stopped"}`);
+    console.log(`  configured: ${status.configured ? "yes" : "no"}`);
+    if (status.command) console.log(`  command: ${status.command}`);
+    if (status.liveHost) {
+      console.log(`  live host: ${status.liveHost.label || status.liveHost.ownerName || status.liveHost.sessionId || status.liveHost.pid}`);
+    } else {
+      console.log("  live host: none");
+    }
+    if (status.staleProcessInfo) {
+      console.log("  stale process file: yes");
+    }
+  }
+}
+
+async function runServicesUp(runtime, { cwd = process.cwd(), asJson = false } = {}) {
+  const result = await maybeAutostartGateway(runtime, { cwd, io: console });
+  if (asJson) {
+    printData(result, true);
+    return;
+  }
+  if (!result.attempted) {
+    console.log(`No channel services started (${result.reason || "not configured"})`);
+    return;
+  }
+  const started = (result.handles || []).filter((item) => item.started);
+  const alreadyRunning = (result.handles || []).filter((item) => item.reason === "already-running");
+  if (started.length) {
+    for (const item of started) {
+      console.log(`Started ${item.service} (pid ${item.pid})`);
+    }
+  }
+  if (alreadyRunning.length) {
+    for (const item of alreadyRunning) {
+      console.log(`${item.service} already running (pid ${item.pid})`);
+    }
+  }
+}
+
+async function runServicesDown({ asJson = false } = {}) {
+  const results = [];
+  for (const service of ["telegram", "discord"]) {
+    const result = await stopTrackedGateway(service, { io: console });
+    await clearTrackedGatewayArtifacts(service);
+    results.push({ service, ...result });
+  }
+  if (asJson) {
+    printData({ services: results }, true);
+    return;
+  }
+  for (const result of results) {
+    console.log(result.stopped ? `Stopped ${result.service} (pid ${result.pid})` : `No running ${result.service} process found`);
+  }
+}
+
+async function runServicesRestart(runtime, { cwd = process.cwd(), asJson = false } = {}) {
+  await runServicesDown({ asJson: false });
+  await sleep(250);
+  await runServicesUp(runtime, { cwd, asJson: false });
+  if (asJson) {
+    await runProcessStatusCommand(runtime, { asJson: true });
+  }
+}
+
 function createTelegramBridgeHostRecord({ sessionId, cwd, label = "", surface = "live-tui", ownerId = "", ownerName = "", provider = "", model = "", runtimeProfile = "" }) {
   const now = new Date().toISOString();
   return {
@@ -4076,7 +4207,9 @@ async function runDiscordCommand(positional, runtime, { asJson = false } = {}) {
   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) });
+  await withTrackedGatewayProcess("discord", "discord run", async () => {
+    await runDiscordGateway(runtime, { log: (line) => console.log(line) });
+  });
 }
 
 async function runChannelsCommand(positional, runtime, { asJson = false } = {}) {
@@ -4227,11 +4360,13 @@ async function runGatewayCommand(positional, runtime, { cwd = process.cwd(), asJ
     if (runtimeRequiresApiKey(runtime) && (!runtime.apiKey || isLikelyPlaceholderApiKey(runtime.apiKey))) {
       throw new Error("Missing provider API key. Run `waterbrother onboarding` or set one with `waterbrother config set apiKey ...`.");
     }
-    await runGatewayService({
-      service,
-      runtime,
-      cwd,
-      io: console
+    await withTrackedGatewayProcess(service, `gateway run ${service}`, async () => {
+      await runGatewayService({
+        service,
+        runtime,
+        cwd,
+        io: console
+      });
     });
     return;
   }
@@ -11360,6 +11495,26 @@ export async function runCli(argv) {
     return;
   }
 
+  if (command === "ps") {
+    await runProcessStatusCommand(runtime, { asJson });
+    return;
+  }
+
+  if (command === "up") {
+    await runServicesUp(runtime, { cwd: startupCwd, asJson });
+    return;
+  }
+
+  if (command === "down") {
+    await runServicesDown({ asJson });
+    return;
+  }
+
+  if (command === "restart") {
+    await runServicesRestart(runtime, { cwd: startupCwd, asJson });
+    return;
+  }
+
   if (command === "models") {
     await runModelsCommand(positional, runtime, { asJson });
     return;

package/src/discord.js

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+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";
 
@@ -113,7 +114,8 @@ function shouldReplyToMessage(message, botUserId) {
   if (!content) return false;
   const dm = !message.guild_id;
   const mentioned = botUserId ? content.includes(`<@${botUserId}>`) || content.includes(`<@!${botUserId}>`) : false;
-  return dm || mentioned;
+  const guildCommand = !dm && content.startsWith("/");
+  return dm || mentioned || guildCommand;
 }
 
 function buildReply(message, botUserId) {
@@ -122,15 +124,32 @@ 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()}`;
 }
@@ -409,6 +428,66 @@ async function handleDiscordSessionCommand(runtime, state, message, command) {
   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 : [];
@@ -488,7 +567,7 @@ async function runPromptViaBridge(runtime, message, promptText, options = {}) {
       nextBridge.deliveredReplies.splice(replyIndex, 1);
       await saveGatewayBridge("discord", nextBridge);
       if (reply.error) {
-      return { error: String(reply.error || "").trim() || "Discord bridge execution failed." };
+        return { error: String(reply.error || "").trim() || "Discord bridge execution failed." };
       }
       return {
         content: String(reply.content || "").trim() || "(no content)",
@@ -651,6 +730,12 @@ export async function runDiscordGateway(runtime = {}, { log = console.log, signa
           }
           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);

package/src/gateway.js

@@ -4914,10 +4914,14 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
         });
         return;
       }
+      const targetBridgeHost = selectedLiveHost || host || null;
+      if (!targetBridgeHost) {
+        throw new Error("No live Waterbrother TUI is connected. Start Waterbrother in the terminal first, then retry.");
+      }
       previewMessage = await this.sendProgressMessage(message.chat.id, message.message_id);
       const result = (await this.runPromptViaBridge(message, sessionId, promptText, {
         explicitExecution: shouldExecutePrompt,
-        targetHost: selectedLiveHost || host || null,
+        targetHost: targetBridgeHost,
         includeSource: true
       }))
         ?? (await this.runPromptFallback(sessionId, promptText));