@tritard/waterbrother 0.16.47 → 0.16.49

package/README.md

@@ -297,6 +297,8 @@ Current Telegram behavior:
 - pending pairings are explicit and expire automatically after 12 hours unless approved
 - paired Telegram users drive the same live session and permissions as the terminal operator when the TUI bridge is attached
 - Telegram now supports remote workspace control with `/project`, `/project use <path|name>`, `/project new <name>`, `/project share`, plus the lower-level `/cwd`, `/use <path>`, `/desktop`, and `/new-project <name>` commands
+- Telegram owners can pair visible chat participants conversationally or with `/pair <user-id|@username>`, then continue with shared-room invites without dropping back to the terminal
+- Telegram owners can also use conversational project and member requests like “share this project in this chat”, “switch to TelegramTest”, or “add Austin as editor”, and Waterbrother routes those through the same project and shared-room actions
 - shared projects now support `/room`, `/events`, `/members`, `/invites`, `/whoami`, `/people`, `/tasks`, `/mode`, `/claim`, `/release`, `/invite`, `/accept-invite`, `/approve-invite`, `/reject-invite`, `/remove-member`, `/room-runtime`, and `/task ...` from Telegram
 - Telegram now supports `/whoami` for Telegram-id and shared-room membership visibility, plus `/events` for recent shared-room activity
 - `/room` now includes pending invite count plus task ownership summaries

package/package.json

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

package/src/gateway.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import { createSession, listSessions, loadSession, saveSession } from "./session-store.js";
 import { DEFAULT_PENDING_PAIRING_TTL_MINUTES, loadGatewayBridge, loadGatewayState, prunePendingPairings, saveGatewayBridge, saveGatewayState } from "./gateway-state.js";
 import { getGatewayStatus, getChannelSpec } from "./channels.js";
+import { getConfigPath, loadConfigLayers, saveConfig } from "./config.js";
 import { canonicalizeLoosePath } from "./path-utils.js";
 import { acceptSharedInvite, addSharedTask, approveSharedInvite, assignSharedTask, claimSharedOperator, claimSharedTask, commentSharedTask, createSharedInvite, enableSharedProject, getSharedTaskHistory, listSharedEvents, listSharedInvites, listSharedTasks, loadSharedProject, moveSharedTask, rejectSharedInvite, releaseSharedOperator, setSharedRoom, setSharedRoomMode, setSharedRuntimeProfile, removeSharedMember, upsertSharedMember } from "./shared-project.js";
 import { buildSelfAwarenessManifest, formatAboutWaterbrother, formatSelfState, resolveLocalConceptQuestion } from "./self-awareness.js";
@@ -29,6 +30,7 @@ const TELEGRAM_COMMANDS = [
   { command: "status", description: "Show the linked remote session" },
   { command: "whoami", description: "Show your Telegram identity and room membership" },
   { command: "people", description: "Show recently seen Telegram people in this chat" },
+  { command: "pair", description: "Pair a known Telegram user from this chat" },
   { command: "project", description: "Show or change the linked project" },
   { command: "cwd", description: "Show the current remote working directory" },
   { command: "runtime", description: "Show active runtime status" },
@@ -210,6 +212,7 @@ function buildRemoteHelp() {
     "<code>/status</code> show the current linked remote session",
     "<code>/whoami</code> show your Telegram identity and room membership",
     "<code>/people</code> list recent Telegram users in this chat for easier invites",
+    "<code>/pair &lt;user-id|@username&gt;</code> pair a known Telegram user from this chat",
     "<code>/project</code> show the linked project and sharing state",
     "<code>/project use &lt;path|name&gt;</code> switch to another project or directory",
     "<code>/project new &lt;name&gt;</code> create a Desktop project and switch into it",
@@ -328,6 +331,54 @@ function parseTelegramProjectIntent(text = "") {
   return null;
 }
 
+function parseTelegramMemberIntent(text = "") {
+  const value = normalizeTelegramProjectIntentText(text);
+  const lowered = value.toLowerCase();
+  if (!value) return null;
+  if (/^(how|what|why|when|where|who)\b/.test(lowered)) return null;
+
+  const roleMatch = lowered.match(/\b(owner|editor|observer)s?\b/);
+  const role = roleMatch?.[1] || "editor";
+  const explicitUsername = value.match(/@([a-zA-Z0-9_]+)/);
+
+  if (explicitUsername && /\b(add|invite|make|set|promote)\b/.test(lowered)) {
+    return { action: "member-upsert", target: `@${explicitUsername[1]}`, role };
+  }
+
+  const patterns = [
+    /^(?:add|invite)\s+(.+?)\s+as\s+(owner|editor|observer)\s*$/i,
+    /^(?:add|invite)\s+(.+?)\s*$/i,
+    /^(?:make|set|promote)\s+(.+?)\s+(?:an?\s+)?(owner|editor|observer)\s*$/i
+  ];
+  for (const pattern of patterns) {
+    const match = value.match(pattern);
+    if (!match) continue;
+    const target = String(match[1] || "").trim();
+    const nextRole = String(match[2] || role || "editor").trim().toLowerCase();
+    if (target) {
+      return { action: "member-upsert", target, role: nextRole };
+    }
+  }
+
+  return null;
+}
+
+function parseTelegramPairingIntent(text = "") {
+  const value = normalizeTelegramProjectIntentText(text);
+  const lowered = value.toLowerCase();
+  if (!value) return null;
+  if (/^(how|what|why|when|where|who)\b/.test(lowered)) return null;
+  const explicitUsername = value.match(/@([a-zA-Z0-9_]+)/);
+  if (explicitUsername && /\b(pair|approve|allow)\b/.test(lowered)) {
+    return { action: "pair", target: `@${explicitUsername[1]}` };
+  }
+  const match = value.match(/^(?:pair|approve|allow)\s+(.+?)\s*$/i);
+  if (match?.[1]) {
+    return { action: "pair", target: match[1].trim() };
+  }
+  return null;
+}
+
 async function buildTelegramSelfAwarenessMarkup({ cwd, runtime, currentSession, kind = "about" }) {
   const manifest = await buildSelfAwarenessManifest({ cwd, runtime, currentSession });
   if (kind === "state") {
@@ -918,6 +969,114 @@ class TelegramGateway {
     throw new Error(`Unknown Telegram user reference: ${value}. Use /people to list recent users in this chat.`);
   }
 
+  resolveKnownPerson(message, target) {
+    const value = String(target || "").trim();
+    if (!value) {
+      throw new Error("member target is required");
+    }
+    if (/^\d+$/.test(value) || value.startsWith("@")) {
+      const match = this.resolveInviteTarget(message, value);
+      return { userId: match.userId, displayName: match.displayName };
+    }
+
+    const normalized = value.toLowerCase();
+    const known = this.listKnownChatPeople(message);
+    const exact = known.find((person) => String(person.displayName || "").trim().toLowerCase() === normalized);
+    if (exact) {
+      return { userId: exact.userId, displayName: exact.displayName || exact.userId };
+    }
+    const partial = known.filter((person) => {
+      const display = String(person.displayName || "").trim().toLowerCase();
+      const handle = String(person.usernameHandle || "").trim().toLowerCase();
+      return display.includes(normalized) || handle === normalized.replace(/^@/, "");
+    });
+    if (partial.length === 1) {
+      return { userId: partial[0].userId, displayName: partial[0].displayName || partial[0].userId };
+    }
+    if (partial.length > 1) {
+      throw new Error(`Multiple Telegram users matched ${value}. Use /people and invite by id or @username.`);
+    }
+    throw new Error(`Unknown Telegram person: ${value}. Use /people to see recent users in this chat.`);
+  }
+
+  async handleConversationalMemberIntent(message, sessionId, intent, peer) {
+    const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
+    if (!project?.enabled) {
+      throw new Error("This project is not shared yet. Use /project share first.");
+    }
+    const target = this.resolveKnownPerson(message, intent.target);
+    const actorId = String(message?.from?.id || "").trim();
+    const actorName = peer?.username || [message?.from?.first_name, message?.from?.last_name].filter(Boolean).join(" ").trim() || actorId;
+    const existingMember = Array.isArray(project.members)
+      ? project.members.find((entry) => String(entry?.id || "").trim() === target.userId) || null
+      : null;
+    if (existingMember) {
+      const nextProject = await upsertSharedMember(
+        session.cwd || this.cwd,
+        { id: target.userId, name: target.displayName || target.userId, role: intent.role, paired: true },
+        { actorId, actorName }
+      );
+      return {
+        kind: "member",
+        project: nextProject,
+        markup: `Updated <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> to <code>${escapeTelegramHtml(intent.role)}</code> in this shared project.`
+      };
+    }
+    const result = await createSharedInvite(
+      session.cwd || this.cwd,
+      { id: target.userId, role: intent.role, name: target.displayName || target.userId, paired: true },
+      { actorId, actorName }
+    );
+    return {
+      kind: "invite",
+      project: result.project,
+      markup: `Created pending invite <code>${escapeTelegramHtml(result.invite.id)}</code> for <code>${escapeTelegramHtml(target.displayName || target.userId)}</code> as <code>${escapeTelegramHtml(result.invite.role)}</code>.\nAsk them to run <code>/accept-invite ${escapeTelegramHtml(result.invite.id)}</code>.`
+    };
+  }
+
+  async pairKnownTelegramUser(message, target) {
+    const { session, project } = await this.bindSharedRoomForMessage(message, await this.ensurePeerSession(message));
+    if (project?.enabled) {
+      const owner = Array.isArray(project.members)
+        ? project.members.find((entry) => String(entry?.id || "").trim() === String(message?.from?.id || "").trim())
+        : null;
+      if (!owner || String(owner.role || "").trim() !== "owner") {
+        throw new Error("Only a shared-project owner can pair new Telegram users from this chat.");
+      }
+    }
+
+    const person = this.resolveKnownPerson(message, target);
+    const { userConfig, projectConfig } = await loadConfigLayers(session.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(person.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: session.cwd || this.cwd });
+
+    this.channel.allowedUserIds = telegram.allowedUserIds;
+    if (this.runtime.channels?.telegram) {
+      this.runtime.channels.telegram.allowedUserIds = telegram.allowedUserIds;
+    }
+
+    if (this.state.pendingPairings?.[person.userId]) {
+      delete this.state.pendingPairings[person.userId];
+    }
+    await this.persistState();
+
+    return {
+      userId: person.userId,
+      displayName: person.displayName || person.userId,
+      configPath: getConfigPath({ scope: targetScope, cwd: session.cwd || this.cwd })
+    };
+  }
+
   async addPendingPairing(message) {
     const { userId, usernameHandle, displayName } = this.describeTelegramUser(message?.from || {});
     this.state.pendingPairings[userId] = {
@@ -1507,6 +1666,25 @@ class TelegramGateway {
       return;
     }
 
+    if (text.startsWith("/pair")) {
+      const rawTarget = text.replace("/pair", "").trim();
+      if (!rawTarget) {
+        await this.sendMarkup(message.chat.id, "Usage: <code>/pair &lt;user-id|@username&gt;</code>", message.message_id);
+        return;
+      }
+      try {
+        const result = await this.pairKnownTelegramUser(message, rawTarget);
+        await this.sendMarkup(
+          message.chat.id,
+          `Paired <code>${escapeTelegramHtml(result.displayName)}</code> <i>(${escapeTelegramHtml(result.userId)})</i> via <code>${escapeTelegramHtml(result.configPath)}</code>.`,
+          message.message_id
+        );
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+
     if (text === "/project") {
       const { session, project } = await this.bindSharedRoomForMessage(message, sessionId);
       await this.sendMarkup(
@@ -2126,6 +2304,30 @@ Ask them to run <code>/whoami</code> and then <code>/accept-invite ${escapeTeleg
       ? (isExplicitRun ? { kind: "execution", reason: "explicit /run" } : classifyTelegramGroupIntent(promptText))
       : { kind: "execution", reason: "private chat" };
     const sharedBinding = await this.bindSharedRoomForMessage(message, sessionId);
+    const pairingIntent = parseTelegramPairingIntent(promptText);
+    if (pairingIntent) {
+      try {
+        const result = await this.pairKnownTelegramUser(message, pairingIntent.target);
+        await this.sendMarkup(
+          message.chat.id,
+          `Paired <code>${escapeTelegramHtml(result.displayName)}</code> <i>(${escapeTelegramHtml(result.userId)})</i> via <code>${escapeTelegramHtml(result.configPath)}</code>.`,
+          message.message_id
+        );
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
+    const memberIntent = parseTelegramMemberIntent(promptText);
+    if (memberIntent) {
+      try {
+        const result = await this.handleConversationalMemberIntent(message, sessionId, memberIntent, peer);
+        await this.sendMarkup(message.chat.id, result.markup, message.message_id);
+      } catch (error) {
+        await this.sendMessage(message.chat.id, escapeTelegramHtml(error instanceof Error ? error.message : String(error)), message.message_id);
+      }
+      return;
+    }
     const projectIntent = parseTelegramProjectIntent(promptText);
     if (projectIntent?.action === "show-project") {
       await this.sendMarkup(