@tritard/waterbrother 0.16.77 → 0.16.78

package/package.json

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

package/src/cli.js

@@ -3023,6 +3023,15 @@ function createTelegramBridgeHostRecord({ sessionId, cwd, label = "", surface =
   };
 }
 
+function upsertTelegramBridgeHostEntry(hosts = [], nextHost = {}) {
+  const list = Array.isArray(hosts) ? [...hosts] : [];
+  const pid = Number(nextHost?.pid || 0);
+  if (!pid) return list;
+  const filtered = list.filter((host) => Number(host?.pid || 0) !== pid);
+  filtered.unshift(nextHost);
+  return filtered.slice(0, 20);
+}
+
 async function syncSharedTelegramBridgeAgent({ cwd, host = {}, actor = {} }) {
   try {
     const project = await loadSharedProject(cwd);
@@ -3052,6 +3061,7 @@ 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);
@@ -3079,6 +3089,7 @@ async function touchTelegramBridgeHost({ sessionId, cwd, label = "", surface = "
       updatedAt: new Date().toISOString()
     };
   }
+  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;
@@ -3088,8 +3099,9 @@ 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: "" };
-    await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, 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 }) {
@@ -3111,6 +3123,7 @@ async function dequeueTelegramBridgeRequest({ cwd }) {
     ...activeHost,
     updatedAt: new Date().toISOString()
   };
+  bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
   return next;
 }
@@ -3135,6 +3148,9 @@ async function deliverTelegramBridgeReply(request, { sessionId, content = "", er
       sessionId: String(sessionId || "").trim() || String(bridge.activeHost.sessionId || "")
     };
   }
+  if (Number(bridge.activeHost?.pid || 0) === process.pid) {
+    bridge.hosts = upsertTelegramBridgeHostEntry(bridge.hosts, bridge.activeHost);
+  }
   await saveGatewayBridge(TELEGRAM_BRIDGE_SERVICE, bridge);
 }
 

package/src/gateway-state.js

@@ -75,29 +75,39 @@ function normalizeBridgeReply(parsed = {}) {
 }
 
 function normalizeGatewayBridge(parsed = {}) {
+  const normalizeHost = (host = {}) => ({
+    pid: Number.isFinite(Number(host.pid)) ? Math.floor(Number(host.pid)) : 0,
+    sessionId: String(host.sessionId || "").trim(),
+    cwd: String(host.cwd || "").trim(),
+    label: String(host.label || "").trim(),
+    surface: String(host.surface || "").trim(),
+    ownerId: String(host.ownerId || "").trim(),
+    ownerName: String(host.ownerName || "").trim(),
+    provider: String(host.provider || "").trim(),
+    model: String(host.model || "").trim(),
+    runtimeProfile: String(host.runtimeProfile || "").trim(),
+    startedAt: String(host.startedAt || "").trim(),
+    updatedAt: String(host.updatedAt || "").trim()
+  });
   const pendingRequests = Array.isArray(parsed?.pendingRequests)
     ? parsed.pendingRequests.map(normalizeBridgeRequest).filter((item) => item.id)
     : [];
   const deliveredReplies = Array.isArray(parsed?.deliveredReplies)
     ? parsed.deliveredReplies.map(normalizeBridgeReply).filter((item) => item.requestId)
     : [];
+  const hosts = Array.isArray(parsed?.hosts)
+    ? parsed.hosts.map(normalizeHost).filter((host) => Number(host.pid || 0) > 0)
+    : [];
+  const activeHost = parsed?.activeHost && typeof parsed.activeHost === "object"
+    ? normalizeHost(parsed.activeHost)
+    : normalizeHost();
+  const mergedHosts = [...hosts];
+  if (Number(activeHost.pid || 0) > 0 && !mergedHosts.some((host) => Number(host.pid || 0) === Number(activeHost.pid || 0))) {
+    mergedHosts.unshift(activeHost);
+  }
   return {
-    activeHost: parsed?.activeHost && typeof parsed.activeHost === "object"
-      ? {
-          pid: Number.isFinite(Number(parsed.activeHost.pid)) ? Math.floor(Number(parsed.activeHost.pid)) : 0,
-          sessionId: String(parsed.activeHost.sessionId || "").trim(),
-          cwd: String(parsed.activeHost.cwd || "").trim(),
-          label: String(parsed.activeHost.label || "").trim(),
-          surface: String(parsed.activeHost.surface || "").trim(),
-          ownerId: String(parsed.activeHost.ownerId || "").trim(),
-          ownerName: String(parsed.activeHost.ownerName || "").trim(),
-          provider: String(parsed.activeHost.provider || "").trim(),
-          model: String(parsed.activeHost.model || "").trim(),
-          runtimeProfile: String(parsed.activeHost.runtimeProfile || "").trim(),
-          startedAt: String(parsed.activeHost.startedAt || "").trim(),
-          updatedAt: String(parsed.activeHost.updatedAt || "").trim()
-        }
-      : { pid: 0, sessionId: "", cwd: "", label: "", surface: "", ownerId: "", ownerName: "", provider: "", model: "", runtimeProfile: "", startedAt: "", updatedAt: "" },
+    activeHost,
+    hosts: mergedHosts.slice(-20),
     pendingRequests,
     deliveredReplies
   };

package/src/gateway.js

@@ -466,6 +466,13 @@ function summarizeRuntimeConflict(project, fallbackExecutor = {}) {
   };
 }
 
+function formatBridgeHostLabel(host = {}) {
+  const owner = String(host?.ownerName || host?.ownerId || "").trim();
+  const label = String(host?.label || "").trim();
+  const runtime = host?.provider && host?.model ? `${host.provider}/${host.model}` : "";
+  return [owner || label, label && label !== owner ? `(${label})` : "", runtime ? `[${runtime}]` : ""].filter(Boolean).join(" ").trim();
+}
+
 function getLatestBlockingReviewPolicy(project) {
   const events = Array.isArray(project?.recentEvents) ? [...project.recentEvents] : [];
   const ordered = events
@@ -730,6 +737,9 @@ function parseTelegramStateIntent(text = "") {
   if (/\bwho are the bots\b/.test(lower) || /\bwho are the agents\b/.test(lower) || /\bwhat bots are here\b/.test(lower) || /\bwhat agents are here\b/.test(lower)) {
     return { action: "agent-list" };
   }
+  if (/\bwhich terminals are live\b/.test(lower) || /\bwhich bots are live\b/.test(lower) || /\bwho is live\b/.test(lower) || /\bwhat terminals are live\b/.test(lower)) {
+    return { action: "live-hosts" };
+  }
   if (/\bmodel conflict\b/.test(lower) || /\bruntime conflict\b/.test(lower) || /\bmodel split\b/.test(lower) || /\bruntime split\b/.test(lower) || /\bcompare models\b/.test(lower) || /\bcompare bots\b/.test(lower)) {
     return { action: "model-conflict" };
   }
@@ -854,6 +864,7 @@ function formatTelegramRoomMarkup(project, options = {}) {
     ? agents.map((agent) => `• ${escapeTelegramHtml(formatAgentLabel(agent) || agent.id || "agent")} <code>${escapeTelegramHtml(agent.surface || "unknown")}</code>`)
     : ["• none"];
   const runtimeConflict = summarizeRuntimeConflict(project, executor);
+  const liveHosts = Array.isArray(options.liveHosts) ? options.liveHosts : [];
   const executorBits = [
     `surface: <code>${escapeTelegramHtml(executor.surface || "telegram")}</code>`,
     `provider: <code>${escapeTelegramHtml(executor.provider || "unknown")}</code>`,
@@ -888,6 +899,11 @@ function formatTelegramRoomMarkup(project, options = {}) {
         .filter(Boolean);
       return `• <code>${escapeTelegramHtml(group.runtime)}</code>${owners.length ? ` — ${escapeTelegramHtml(owners.join(", "))}` : ""}`;
     }),
+    "<b>Live Terminals</b>",
+    `count: <code>${escapeTelegramHtml(String(liveHosts.length))}</code>`,
+    ...(liveHosts.length
+      ? liveHosts.map((host) => `• ${escapeTelegramHtml(formatBridgeHostLabel(host) || host.sessionId || "terminal")} <code>${escapeTelegramHtml(host.surface || "live-tui")}</code>`)
+      : ["• none"]),
     "<b>Task Summary</b>",
     `total: <code>${tasks.length}</code>`,
     ...[...byState.entries()].map(([state, count]) => `${escapeTelegramHtml(state)}: <code>${count}</code>`),
@@ -2067,6 +2083,20 @@ class TelegramGateway {
       ].join("\n");
     }
 
+    if (intent.action === "live-hosts") {
+      const hosts = await this.getLiveBridgeHosts({ cwd });
+      if (!hosts.length) {
+        return "<b>Live terminals</b>\n• none";
+      }
+      return [
+        "<b>Live terminals</b>",
+        ...hosts.map((host) => {
+          const roleAgent = listProjectAgents(project).find((agent) => String(agent?.sessionId || "").trim() === String(host?.sessionId || "").trim()) || null;
+          return `• ${escapeTelegramHtml(formatBridgeHostLabel(host) || host.sessionId || "terminal")} <i>(${escapeTelegramHtml(roleAgent?.role || "live")})</i> <code>${escapeTelegramHtml(host.surface || "live-tui")}</code>`;
+        })
+      ].join("\n");
+    }
+
     if (intent.action === "model-conflict") {
       if (!project?.enabled) {
         return "This project is not shared.";
@@ -2141,12 +2171,20 @@ class TelegramGateway {
       const operatorLabel = project.activeOperator?.id
         ? `${project.activeOperator.name || project.activeOperator.id}`
         : "none";
+      const liveHosts = await this.getLiveBridgeHosts({ cwd });
+      const isLive = liveHosts.some((host) => {
+        const ownerId = String(host?.ownerId || "").trim();
+        const sessionId = String(host?.sessionId || "").trim();
+        return (ownerId && ownerId === String(agent.ownerId || "").trim())
+          || (sessionId && sessionId === String(agent.sessionId || "").trim());
+      });
       return [
         "<b>Execution recommendation</b>",
         `take this on: <code>${escapeTelegramHtml(agent.ownerName || agent.label || agent.ownerId || agent.id || "unknown")}</code>`,
         `role: <code>${escapeTelegramHtml(agent.role || "executor")}</code>`,
         `surface: <code>${escapeTelegramHtml(agent.surface || "unknown")}</code>`,
         `runtime: <code>${escapeTelegramHtml(agent.provider && agent.model ? `${agent.provider}/${agent.model}` : "unknown")}</code>`,
+        `live now: <code>${escapeTelegramHtml(isLive ? "yes" : "no")}</code>`,
         `active operator: <code>${escapeTelegramHtml(operatorLabel)}</code>`
       ].join("\n");
     }
@@ -2493,6 +2531,7 @@ class TelegramGateway {
   async buildRoomMarkup(message, sessionId) {
     const { project } = await this.bindSharedRoomForMessage(message, sessionId);
     const host = await this.getLiveBridgeHost();
+    const liveHosts = await this.getLiveBridgeHosts({ cwd: project?.cwd || this.cwd });
     const executor = {
       surface: host?.surface || (host ? "live-tui" : "telegram-fallback"),
       provider: host?.provider || this.runtime.provider,
@@ -2504,10 +2543,10 @@ class TelegramGateway {
       ? `${formatTelegramSummaryMarkup({
           cwd: project.cwd || this.cwd,
           project,
-          chatId: String(message.chat.id),
-          title: String(message.chat.title || "").trim(),
-          executor
-        })}\n\n${formatTelegramRoomMarkup(project, { executor })}`
+        chatId: String(message.chat.id),
+        title: String(message.chat.title || "").trim(),
+        executor
+        })}\n\n${formatTelegramRoomMarkup(project, { executor, liveHosts })}`
       : "<b>Shared room</b>\nThis project is not shared.";
   }
 
@@ -2558,6 +2597,39 @@ class TelegramGateway {
     return host;
   }
 
+  async getLiveBridgeHosts({ cwd = "" } = {}) {
+    const bridge = await loadGatewayBridge("telegram");
+    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("telegram", bridge);
+    }
+    return nextHosts;
+  }
+
   async runPromptViaBridge(message, sessionId, promptText, options = {}) {
     const host = await this.getLiveBridgeHost();
     if (!host) {