@tritard/waterbrother 0.16.62 → 0.16.64

package/package.json

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

package/src/gateway-state.js

@@ -18,10 +18,24 @@ function gatewayBridgePath(serviceId) {
 }
 
 function normalizeGatewayState(parsed = {}) {
+  const continuations = parsed?.continuations && typeof parsed.continuations === "object" ? parsed.continuations : {};
   return {
     offset: Number.isFinite(Number(parsed?.offset)) ? Math.max(0, Math.floor(Number(parsed.offset))) : 0,
     peers: parsed?.peers && typeof parsed.peers === "object" ? parsed.peers : {},
-    pendingPairings: parsed?.pendingPairings && typeof parsed.pendingPairings === "object" ? parsed.pendingPairings : {}
+    pendingPairings: parsed?.pendingPairings && typeof parsed.pendingPairings === "object" ? parsed.pendingPairings : {},
+    continuations: Object.fromEntries(
+      Object.entries(continuations).map(([key, item]) => [
+        key,
+        {
+          chatId: String(item?.chatId || "").trim(),
+          userId: String(item?.userId || "").trim(),
+          lastPrompt: String(item?.lastPrompt || "").trim(),
+          kind: String(item?.kind || "follow-up").trim() || "follow-up",
+          source: String(item?.source || "assistant-question").trim() || "assistant-question",
+          expiresAt: String(item?.expiresAt || "").trim()
+        }
+      ])
+    )
   };
 }
 
@@ -114,7 +128,7 @@ export async function loadGatewayState(serviceId) {
     return normalizeGatewayState(JSON.parse(raw));
   } catch (error) {
     if (error?.code === "ENOENT") {
-      return { offset: 0, peers: {}, pendingPairings: {} };
+      return { offset: 0, peers: {}, pendingPairings: {}, continuations: {} };
     }
     throw error;
   }

package/src/gateway.js

@@ -22,6 +22,7 @@ const TELEGRAM_TYPING_INTERVAL_MS = 4000;
 const TELEGRAM_PREVIEW_TEXT = "<i>Working…</i>";
 const TELEGRAM_BRIDGE_TIMEOUT_MS = 5 * 60 * 1000;
 const TELEGRAM_BRIDGE_POLL_MS = 250;
+const TELEGRAM_CONTINUATION_TTL_MS = 15 * 60 * 1000;
 const TELEGRAM_COMMANDS = [
   { command: "help", description: "Show Telegram control help" },
   { command: "about", description: "Show local Waterbrother identity and capabilities" },
@@ -98,6 +99,10 @@ function getTelegramBotAliases(me = {}) {
   return [...aliases].filter(Boolean);
 }
 
+function continuationKey(chatId, userId) {
+  return `${String(chatId || "").trim()}:${String(userId || "").trim()}`;
+}
+
 function splitLongPlainText(text, maxLength = TELEGRAM_MESSAGE_LIMIT) {
   const value = String(text || "").trim();
   if (!value) return [""];
@@ -749,6 +754,16 @@ function classifyTelegramGroupIntent(text = "") {
   return { kind: "chat", reason: "default non-execution" };
 }
 
+function buildContinuationPrompt(text = "", continuation = null) {
+  const body = String(text || "").trim();
+  if (!continuation?.lastPrompt) return body;
+  return [
+    `Continue the active Telegram follow-up.`,
+    `Your last question/request to this user was: ${continuation.lastPrompt}`,
+    `User reply: ${body}`
+  ].join("\n");
+}
+
 function suggestTaskText(text = "") {
   return String(text || "")
     .replace(/^@[\w_]+\s*/g, "")
@@ -944,6 +959,7 @@ class TelegramGateway {
     const replyFromId = String(message?.reply_to_message?.from?.id || "").trim();
     const myId = String(this.me?.id || "").trim();
     if (replyFromId && myId && replyFromId === myId) return true;
+    if (this.hasPendingContinuation(message)) return true;
     return false;
   }
 
@@ -960,7 +976,15 @@ class TelegramGateway {
 
   prunePairings() {
     const { state, pruned } = prunePendingPairings(this.state, this.pairingExpiryMinutes);
-    this.state = state;
+    const continuations = {};
+    const now = Date.now();
+    for (const [key, item] of Object.entries(state.continuations || {})) {
+      const expiresAtMs = Date.parse(String(item?.expiresAt || ""));
+      if (Number.isFinite(expiresAtMs) && expiresAtMs > now) {
+        continuations[key] = item;
+      }
+    }
+    this.state = { ...state, continuations };
     return pruned;
   }
 
@@ -969,6 +993,142 @@ class TelegramGateway {
     await saveGatewayState("telegram", this.state);
   }
 
+  hasPendingContinuation(message) {
+    const key = continuationKey(message?.chat?.id, message?.from?.id);
+    const item = this.state?.continuations?.[key];
+    if (!item) return false;
+    const expiresAtMs = Date.parse(String(item.expiresAt || ""));
+    return Number.isFinite(expiresAtMs) && expiresAtMs > Date.now();
+  }
+
+  getPendingContinuation(message) {
+    const key = continuationKey(message?.chat?.id, message?.from?.id);
+    const item = this.state?.continuations?.[key];
+    if (!item) return null;
+    const expiresAtMs = Date.parse(String(item.expiresAt || ""));
+    if (!Number.isFinite(expiresAtMs) || expiresAtMs <= Date.now()) return null;
+    return item;
+  }
+
+  clearContinuation(message) {
+    const key = continuationKey(message?.chat?.id, message?.from?.id);
+    if (this.state?.continuations?.[key]) {
+      delete this.state.continuations[key];
+    }
+  }
+
+  async rememberContinuation(message, text = "") {
+    const body = String(text || "").trim();
+    if (!body) return;
+    const asksFollowUp =
+      /\?\s*$/.test(body)
+      || /\b(would you like|do you want|which\b|what\b.*\?|how\b.*\?|who\b.*\?|where\b.*\?)\b/i.test(body);
+    if (!asksFollowUp) return;
+    const key = continuationKey(message?.chat?.id, message?.from?.id);
+    this.state.continuations[key] = {
+      chatId: String(message?.chat?.id || "").trim(),
+      userId: String(message?.from?.id || "").trim(),
+      lastPrompt: body.slice(0, 400),
+      kind: "follow-up",
+      source: "assistant-question",
+      expiresAt: new Date(Date.now() + TELEGRAM_CONTINUATION_TTL_MS).toISOString()
+    };
+    await this.persistState();
+  }
+
+  async loadTrustedChatProject(message) {
+    if (!this.isGroupChat(message)) return { cwd: "", project: null };
+    const chatId = String(message?.chat?.id || "").trim();
+    const bridge = await loadGatewayBridge("telegram");
+    const candidateCwds = [
+      String(bridge.activeHost?.cwd || "").trim(),
+      String(this.cwd || "").trim()
+    ].filter(Boolean);
+    for (const candidateCwd of candidateCwds) {
+      try {
+        const project = await loadSharedProject(candidateCwd);
+        if (project?.enabled && String(project.room?.provider || "") === "telegram" && String(project.room?.chatId || "") === chatId) {
+          return { cwd: candidateCwd, project };
+        }
+      } catch {}
+    }
+    return { cwd: "", project: null };
+  }
+
+  async autoPairTrustedParticipant(message, cwd) {
+    const { userId, usernameHandle, displayName } = this.describeTelegramUser(message?.from || {});
+    const { userConfig, projectConfig } = await loadConfigLayers(cwd || this.cwd);
+    const targetScope = projectConfig?.channels?.telegram ? "project" : "user";
+    const targetConfig = targetScope === "project" ? { ...projectConfig } : { ...userConfig };
+    const channels = targetConfig.channels && typeof targetConfig.channels === "object" ? { ...targetConfig.channels } : {};
+    const telegram = channels.telegram && typeof channels.telegram === "object" ? { ...channels.telegram } : {};
+    const allowed = new Set(Array.isArray(telegram.allowedUserIds) ? telegram.allowedUserIds.map((value) => String(value || "").trim()).filter(Boolean) : []);
+    allowed.add(userId);
+    telegram.enabled = telegram.enabled !== false;
+    if (!telegram.pairingMode) telegram.pairingMode = "manual";
+    telegram.allowedUserIds = [...allowed];
+    channels.telegram = telegram;
+    targetConfig.channels = channels;
+    await saveConfig(targetConfig, { scope: targetScope, cwd: cwd || this.cwd });
+    this.channel.allowedUserIds = telegram.allowedUserIds;
+    if (this.runtime.channels?.telegram) {
+      this.runtime.channels.telegram.allowedUserIds = telegram.allowedUserIds;
+    }
+    delete this.state.pendingPairings[userId];
+    this.state.peers[userId] = {
+      ...(this.state.peers[userId] || {}),
+      chatId: String(message.chat.id),
+      username: displayName,
+      usernameHandle,
+      displayName,
+      linkedAt: this.state.peers[userId]?.linkedAt || new Date().toISOString(),
+      lastSeenAt: new Date().toISOString(),
+      lastMessageId: message.message_id,
+      sessions: Array.isArray(this.state.peers[userId]?.sessions) ? this.state.peers[userId].sessions : []
+    };
+    await this.persistState();
+  }
+
+  async maybeAutoOnboardTrustedParticipant(message) {
+    if (!this.isGroupChat(message)) return null;
+    const { cwd, project } = await this.loadTrustedChatProject(message);
+    if (!project?.enabled) return null;
+    const actor = this.describeTelegramUser(message?.from || {});
+    const existingMember = Array.isArray(project.members)
+      ? project.members.find((member) => String(member?.id || "").trim() === actor.userId) || null
+      : null;
+    if (existingMember && this.isAuthorizedUser(message.from)) return null;
+    if (!this.isAuthorizedUser(message.from)) {
+      await this.autoPairTrustedParticipant(message, cwd);
+    }
+    const nextProject = existingMember
+      ? project
+      : await upsertSharedMember(
+          cwd,
+          { id: actor.userId, name: actor.displayName || actor.userId, role: "observer", paired: true },
+          { actorId: "system:trusted-room", actorName: "trusted room" }
+        );
+    return {
+      cwd,
+      project: nextProject,
+      actor
+    };
+  }
+
+  buildTrustedRoomIntroMarkup({ project, actor }) {
+    return [
+      "<b>Roundtable room</b>",
+      `${escapeTelegramHtml(actor.displayName || actor.userId)} is now in <code>${escapeTelegramHtml(project.projectName || "this project")}</code> as <code>observer</code>.`,
+      `room mode: <code>${escapeTelegramHtml(project.roomMode || "chat")}</code>`,
+      project.activeOperator?.id
+        ? `active operator: <code>${escapeTelegramHtml(project.activeOperator.name || project.activeOperator.id)}</code>`
+        : "active operator: <code>none</code>",
+      "As observer, you can ask questions, discuss plans, and review work here.",
+      "An owner can promote you to editor or owner conversationally.",
+      "Examples: <code>what project is this chat bound to?</code>, <code>who is in the room?</code>, <code>what can I do here?</code>"
+    ].join("\n");
+  }
+
   describeTelegramUser(from = {}) {
     const userId = String(from?.id || "").trim();
     const usernameHandle = String(from?.username || "").trim();
@@ -1837,12 +1997,20 @@ class TelegramGateway {
     if (!message?.text) return;
     if (!this.messageTargetsBot(message)) return;
     this.prunePairings();
+    const trustedOnboarding = !this.isAuthorizedUser(message.from)
+      ? await this.maybeAutoOnboardTrustedParticipant(message)
+      : null;
     if (!this.isAuthorizedUser(message.from)) {
       await this.rejectUnpairedMessage(message);
       return;
     }
+    if (trustedOnboarding) {
+      await this.sendMarkup(message.chat.id, this.buildTrustedRoomIntroMarkup(trustedOnboarding), message.message_id);
+    }
 
     const text = this.normalizeTelegramCommandText(String(message.text || "").trim());
+    const continuation = this.getPendingContinuation(message);
+    this.clearContinuation(message);
     const userId = String(message.from.id);
 
     if (text === "/help" || text === "/start") {
@@ -2561,9 +2729,14 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
     }
 
     const isExplicitRun = text.startsWith("/run ");
-    const promptText = this.stripBotMention(isExplicitRun ? text.replace("/run", "").trim() : text);
+    const rawPromptText = this.stripBotMention(isExplicitRun ? text.replace("/run", "").trim() : text);
+    const promptText = continuation ? buildContinuationPrompt(rawPromptText, continuation) : rawPromptText;
     const groupIntent = this.isGroupChat(message)
-      ? (isExplicitRun ? { kind: "execution", reason: "explicit /run" } : classifyTelegramGroupIntent(promptText))
+      ? (isExplicitRun
+          ? { kind: "execution", reason: "explicit /run" }
+          : continuation
+            ? { kind: "execution", reason: "follow-up continuation" }
+            : classifyTelegramGroupIntent(rawPromptText))
       : { kind: "execution", reason: "private chat" };
     const shouldExecutePrompt = !this.isGroupChat(message) || groupIntent.kind === "execution";
     const sharedBinding = await this.bindSharedRoomForMessage(message, sessionId);
@@ -2738,6 +2911,7 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
       const content = (await this.runPromptViaBridge(message, sessionId, promptText, { explicitExecution: shouldExecutePrompt }))
         ?? (await this.runPromptFallback(sessionId, promptText));
       await this.deliverPromptResult(message.chat.id, message.message_id, previewMessage, content);
+      await this.rememberContinuation(message, content);
     } catch (error) {
       await this.deliverPromptFailure(message.chat.id, message.message_id, previewMessage, error);
     } finally {