@tritard/waterbrother 0.16.47 → 0.16.48

package/README.md

@@ -297,6 +297,7 @@ 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 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.48",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/gateway.js

@@ -328,6 +328,38 @@ 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;
+}
+
 async function buildTelegramSelfAwarenessMarkup({ cwd, runtime, currentSession, kind = "about" }) {
   const manifest = await buildSelfAwarenessManifest({ cwd, runtime, currentSession });
   if (kind === "state") {
@@ -918,6 +950,71 @@ 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 addPendingPairing(message) {
     const { userId, usernameHandle, displayName } = this.describeTelegramUser(message?.from || {});
     this.state.pendingPairings[userId] = {
@@ -2126,6 +2223,16 @@ 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 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(