macroclaw 0.45.0 → 0.47.0

package/README.md

@@ -8,8 +8,10 @@ A lightweight bridge that turns a Telegram chat into a personal AI assistant —
 
 Macroclaw runs with `dangerouslySkipPermissions` enabled. This is intentional — the bot
 is designed to run in an isolated environment (container or VM) where the workspace is
-the entire world. The single authorized chat ID ensures only one user can interact with
-the bot. See [Docker](#docker) for the recommended containerized setup.
+the entire world. Access is gated by an allowlist of authorized chat IDs: an **admin
+chat** configured at setup, plus any additional chats the admin authorizes at runtime
+via `/chatsadd`. Every other chat is silently ignored. See [Docker](#docker) for the
+recommended containerized setup.
 
 ## Requirements
 
@@ -37,16 +39,18 @@ On subsequent runs, settings are pre-filled from the file.
 
 Settings are stored in `~/.macroclaw/settings.json` and validated on startup.
 
-| Setting        | Env var override       | Default                    | Required |
-|----------------|------------------------|----------------------------|----------|
-| `botToken`     | `TELEGRAM_BOT_TOKEN`   | —                          | Yes      |
-| `chatId`       | `AUTHORIZED_CHAT_ID`   | —                          | Yes      |
-| `model`        | `MODEL`                | `sonnet`                   | No       |
-| `workspace`    | `WORKSPACE`            | `~/.macroclaw-workspace`   | No       |
-| `timeZone`     | `TIMEZONE`             | `UTC`                      | No       |
-| `openaiApiKey` | `OPENAI_API_KEY`       | —                          | No       |
-| `logLevel`     | `LOG_LEVEL`            | `info`                     | No       |
-| `pinoramaUrl`  | `PINORAMA_URL`         | —                          | No       |
+| Setting         | Env var override       | Default                    | Required |
+|-----------------|------------------------|----------------------------|----------|
+| `botToken`      | `TELEGRAM_BOT_TOKEN`   | —                          | Yes      |
+| `adminChatId`   | `ADMIN_CHAT_ID`        | —                          | Yes      |
+| `model`         | `MODEL`                | `sonnet`                   | No       |
+| `workspace`     | `WORKSPACE`            | `~/.macroclaw-workspace`   | No       |
+| `timeZone`      | `TIMEZONE`             | `UTC`                      | No       |
+| `openaiApiKey`  | `OPENAI_API_KEY`       | —                          | No       |
+| `logLevel`      | `LOG_LEVEL`            | `info`                     | No       |
+| `pinoramaUrl`   | `PINORAMA_URL`         | —                          | No       |
+
+`AUTHORIZED_CHAT_ID` is still accepted as a legacy alias for `ADMIN_CHAT_ID`.
 
 **`timeZone`** sets the agent's local time zone (IANA format, e.g. `Europe/Prague`, `America/New_York`). Used for the agent's clock display and scheduled event timing.
 
@@ -54,7 +58,36 @@ Settings are stored in `~/.macroclaw/settings.json` and validated on startup.
 
 Env vars take precedence over settings file values. On startup, a masked settings summary is printed showing which values were overridden by env vars.
 
-Session state (Claude session IDs) is stored separately in `~/.macroclaw/sessions.json`.
+Session state (Claude session IDs) is stored separately in `~/.macroclaw/sessions.json`, keyed by chat name. Runtime-authorized chats are persisted in `~/.macroclaw/authorized-chats.json`.
+
+### Multi-chat
+
+One admin chat is configured at setup and is always authorized. To authorize additional chats at runtime, send these commands from the admin chat:
+
+| Command | Description |
+|---------|-------------|
+| `/chats` | List authorized chats |
+| `/chatsadd <chatId> <name>` | Authorize a new chat. `name` is a lowercase-kebab-case label (e.g. `family`, `work`) used in cron routing and session storage. |
+| `/chatsremove <name>` | Revoke authorization and clear the chat's session |
+| `/chatsremove` (no arg) | Admin: show a button picker. Non-admin authorized chats: self-removal. |
+
+Each authorized chat has its own independent Claude session — memory, context, and tone stay isolated per chat. The agent knows which chat it's responding to via a `chat="<name>"` attribute on every event.
+
+### Group chats and Telegram Privacy Mode
+
+By default, Telegram puts bots in **Privacy Mode** when they're added to groups, which means the bot only receives:
+
+- Messages that start with `/` (commands)
+- Messages that @mention the bot
+- Replies to the bot's own messages
+
+Plain text in the group is filtered out by Telegram before it reaches the bot, so the bot appears silent. To let the bot see every message in a group:
+
+1. Message [@BotFather](https://t.me/BotFather)
+2. `/mybots` → select your bot → **Bot Settings** → **Group Privacy** → **Turn off**
+3. Kick the bot from the group and re-add it — the privacy change only applies to fresh group memberships
+
+Private (1:1) chats are unaffected.
 
 ## Commands
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "macroclaw",
-  "version": "0.45.0",
+  "version": "0.47.0",
   "description": "Telegram-to-Claude-Code bridge",
   "license": "MIT",
   "type": "module",

package/src/app.test.ts

@@ -1,8 +1,9 @@
 import { afterEach, beforeEach, describe, expect, it, mock } from "bun:test";
 import { existsSync, rmSync } from "node:fs";
 import { App, type AppConfig } from "./app";
+import { AuthorizedChats } from "./authorized-chats";
 import { type Claude, type ClaudeProcess, type ProcessState, QueryProcessError, type QueryResult } from "./claude";
-import { saveSessions } from "./sessions";
+import { loadSessions, saveSessions } from "./sessions";
 import type { SpeechToText } from "./speech-to-text";
 
 const mockTranscribe = mock(async (_filePath: string) => "transcribed text");
@@ -50,6 +51,20 @@ mock.module("grammy", () => ({
       opts.onStart({ username: "test_bot", id: 123 });
     }
   },
+  InlineKeyboard: class MockInlineKeyboard {
+    inline_keyboard: Array<Array<{ text: string; callback_data: string }>> = [[]];
+    text(label: string, data: string) {
+      this.inline_keyboard[this.inline_keyboard.length - 1].push({ text: label, callback_data: data });
+      return this;
+    }
+    row() {
+      this.inline_keyboard.push([]);
+      return this;
+    }
+  },
+  InputFile: class MockInputFile {
+    constructor(public path: string) {}
+  },
 }));
 
 const tmpSettingsDir = "/tmp/macroclaw-test-settings";
@@ -59,7 +74,7 @@ beforeEach(() => {
   mockTranscribe.mockReset();
   mockTranscribe.mockImplementation(async () => "transcribed text");
   if (existsSync(tmpSettingsDir)) rmSync(tmpSettingsDir, { recursive: true });
-  saveSessions({ mainSessionId: "test-session" }, tmpSettingsDir);
+  saveSessions({ mainSessions: { admin: "test-session" } }, tmpSettingsDir);
 });
 
 afterEach(async () => {
@@ -130,7 +145,7 @@ function sentPrompts(claude: { processes: ClaudeProcess<unknown>[] }): string[]
 function makeConfig(overrides?: Partial<AppConfig>): AppConfig {
   return {
     botToken: "test-token",
-    authorizedChatId: "12345",
+    adminChatId: "12345",
     workspace: "/tmp/macroclaw-test-workspace",
     model: "sonnet",
     timeZone: "UTC",
@@ -169,13 +184,16 @@ describe("App", () => {
     expect(bot.filterHandlers.has("callback_query:data")).toBe(true);
   });
 
-  it("registers chatid, bg, sessions, and clear commands", () => {
+  it("registers chatid, bg, sessions, clear, and chats commands", () => {
     const app = makeApp();
     const bot = app.bot as any;
     expect(bot.commandHandlers.has("chatid")).toBe(true);
     expect(bot.commandHandlers.has("bg")).toBe(true);
     expect(bot.commandHandlers.has("sessions")).toBe(true);
     expect(bot.commandHandlers.has("clear")).toBe(true);
+    expect(bot.commandHandlers.has("chats")).toBe(true);
+    expect(bot.commandHandlers.has("chatsadd")).toBe(true);
+    expect(bot.commandHandlers.has("chatsremove")).toBe(true);
   });
 
   it("registers error handler", () => {
@@ -793,11 +811,373 @@ describe("App", () => {
       handler(ctx);
       await new Promise((r) => setTimeout(r, 50));
 
-      // No sendMessage calls for unauthorized
       expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
     });
 
+    describe("/chats", () => {
+      it("lists authorized chats for admin", async () => {
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chats")!;
+
+        handler({ chat: { id: 12345 } });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        const text = calls[calls.length - 1][1];
+        expect(text).toContain("family");
+        expect(text).toContain("55555");
+      });
+
+      it("reports no chats when list is empty", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chats")!;
+
+        handler({ chat: { id: 12345 } });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe("No authorized chats.");
+      });
+
+      it("is ignored for non-admin chats", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chats")!;
+
+        handler({ chat: { id: 99999 } });
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
+      });
+    });
+
+    describe("/chatsadd", () => {
+      it("adds chat and creates orchestrator for it", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "55555 family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe('Chat "family" (55555) authorized.');
+      });
+
+      it("sends usage hint when args are missing", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "55555" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("Usage:");
+      });
+
+      it("sends usage hint when match is empty", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("Usage:");
+      });
+
+      it("sends error for invalid chat name", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "55555 InvalidName" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("Error:");
+      });
+
+      it("sends error for duplicate chat", async () => {
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "55555 family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("Error:");
+      });
+
+      it("rejects chatId that matches the admin chat", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 12345 }, match: "12345 family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("already the admin chat");
+      });
+
+      it("is ignored for non-admin chats", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsadd")!;
+
+        handler({ chat: { id: 99999 }, match: "55555 family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
+      });
+
+      it("newly added chat can send messages", async () => {
+        const config = makeConfig();
+        const app = trackApp(new App(config));
+        const bot = app.bot as any;
+
+        const addHandler = bot.commandHandlers.get("chatsadd")!;
+        addHandler({ chat: { id: 12345 }, match: "55555 family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const claude = config.claude as Claude & { calls: CallInfo[]; processes: ClaudeProcess<unknown>[] };
+        const callsBefore = claude.calls.length;
+
+        const textHandler = bot.filterHandlers.get("message:text")![0];
+        textHandler({ chat: { id: 55555 }, message: { text: "hello from family" } });
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect(claude.calls.length).toBeGreaterThan(callsBefore);
+      });
+    });
+
+    describe("/chatsremove", () => {
+      it("removes chat and clears its session", async () => {
+        saveSessions({ mainSessions: { admin: "admin-sid", family: "fam-sid" } }, tmpSettingsDir);
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 12345 }, match: "family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe('Chat "family" removed.');
+
+        const sessions = loadSessions(tmpSettingsDir);
+        expect(sessions.mainSessions.family).toBeUndefined();
+        expect(sessions.mainSessions.admin).toBe("admin-sid");
+      });
+
+      it("reports when no chats to remove and no arg given", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 12345 }, match: "" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe("No authorized chats to remove.");
+      });
+
+      it("sends chat-picker buttons when no arg and chats exist", async () => {
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        authorizedChats.add("66666", "work");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 12345 }, match: "" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        const lastCall = calls[calls.length - 1];
+        expect(lastCall[1]).toBe("Which chat to remove?");
+        const keyboard = lastCall[2].reply_markup.inline_keyboard.flat();
+        const labels = keyboard.map((b: any) => b.text);
+        expect(labels).toEqual(["family", "work", "Dismiss"]);
+        expect(keyboard.find((b: any) => b.text === "family").callback_data).toBe("chatsremove:family");
+      });
+
+      it("button callback removes the selected chat", async () => {
+        saveSessions({ mainSessions: { admin: "admin-sid", family: "fam-sid" } }, tmpSettingsDir);
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.filterHandlers.get("callback_query:data")![0];
+
+        const ctx = {
+          chat: { id: 12345 },
+          callbackQuery: { data: "chatsremove:family" },
+          answerCallbackQuery: mock(async () => {}),
+          editMessageReplyMarkup: mock(async () => {}),
+        };
+
+        await handler(ctx);
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect(ctx.editMessageReplyMarkup).toHaveBeenCalledWith({ reply_markup: { inline_keyboard: [[{ text: "✓ Removed family", callback_data: "_noop" }]] } });
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe('Chat "family" removed.');
+
+        const sessions = loadSessions(tmpSettingsDir);
+        expect(sessions.mainSessions.family).toBeUndefined();
+      });
+
+      it("button callback is ignored for non-admin chats", async () => {
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("99999", "intruder");
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.filterHandlers.get("callback_query:data")![0];
+
+        const ctx = {
+          chat: { id: 99999 },
+          callbackQuery: { data: "chatsremove:intruder" },
+          answerCallbackQuery: mock(async () => {}),
+          editMessageReplyMarkup: mock(async () => {}),
+        };
+
+        await handler(ctx);
+        await new Promise((r) => setTimeout(r, 50));
+
+        // Intruder is still authorized
+        expect(authorizedChats.byName("intruder")).toBeDefined();
+      });
+
+      it("sends error for unknown chat name", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 12345 }, match: "ghost" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toContain("Error:");
+      });
+
+      it("ignores explicit-name removal from non-admin chats", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 99999 }, match: "family" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
+      });
+
+      it("self-removes when called from non-admin chat with no arg", async () => {
+        const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+        authorizedChats.add("55555", "family");
+        saveSessions({ mainSessions: { admin: "a", family: "f" } }, tmpSettingsDir);
+        const app = makeApp({ authorizedChats });
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 55555 }, match: "" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        const calls = (bot.api.sendMessage as any).mock.calls;
+        expect(calls[calls.length - 1][1]).toBe('Chat "family" removed.');
+        expect(authorizedChats.byName("family")).toBeUndefined();
+        expect(loadSessions(tmpSettingsDir).mainSessions.family).toBeUndefined();
+      });
+
+      it("ignores no-arg self-removal from unauthorized non-admin chat", async () => {
+        const app = makeApp();
+        const bot = app.bot as any;
+        const handler = bot.commandHandlers.get("chatsremove")!;
+
+        await handler({ chat: { id: 77777 }, match: "" });
+        await new Promise((r) => setTimeout(r, 50));
+
+        expect((bot.api.sendMessage as any).mock.calls.length).toBe(0);
+      });
+    });
+  });
+
+  describe("handleCron", () => {
+    it("routes cron job with no chat to admin orchestrator", async () => {
+      const config = makeConfig();
+      const app = trackApp(new App(config));
+
+      const claude = config.claude as Claude & { calls: CallInfo[] };
+      const callsBefore = claude.calls.length;
+      app.handleCron("check-in", "any news?", undefined, undefined, undefined);
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(claude.calls.length).toBeGreaterThan(callsBefore);
+    });
+
+    it("routes cron job with chat:'admin' to admin orchestrator", async () => {
+      const config = makeConfig();
+      const app = trackApp(new App(config));
+
+      const claude = config.claude as Claude & { calls: CallInfo[] };
+      const callsBefore = claude.calls.length;
+      app.handleCron("check-in", "any news?", undefined, undefined, "admin");
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(claude.calls.length).toBeGreaterThan(callsBefore);
+    });
+
+    it("routes cron job with chat name to that chat's orchestrator", async () => {
+      const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+      authorizedChats.add("55555", "family");
+      const config = makeConfig({ authorizedChats });
+      const app = trackApp(new App(config));
+
+      const claude = config.claude as Claude & { calls: CallInfo[] };
+      const callsBefore = claude.calls.length;
+      app.handleCron("family-update", "hello family", undefined, undefined, "family");
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(claude.calls.length).toBeGreaterThan(callsBefore);
+    });
+
+    it("broadcasts cron job with chat:'*' to all orchestrators", async () => {
+      const authorizedChats = new AuthorizedChats(tmpSettingsDir);
+      authorizedChats.add("55555", "family");
+      const config = makeConfig({ authorizedChats });
+      const app = trackApp(new App(config));
+
+      const claude = config.claude as Claude & { calls: CallInfo[] };
+      const callsBefore = claude.calls.length;
+      app.handleCron("broadcast", "everyone", undefined, undefined, "*");
+      await new Promise((r) => setTimeout(r, 50));
+
+      // 2 orchestrators (admin + family) → at least 2 additional claude calls
+      expect(claude.calls.length).toBeGreaterThanOrEqual(callsBefore + 2);
+    });
+
+    it("warns and does nothing for unknown chat name", async () => {
+      const config = makeConfig();
+      const app = trackApp(new App(config));
 
+      const claude = config.claude as Claude & { calls: CallInfo[] };
+      const callsBefore = claude.calls.length;
+      app.handleCron("orphan", "hello?", undefined, undefined, "nobody");
+      await new Promise((r) => setTimeout(r, 50));
+
+      expect(claude.calls.length).toBe(callsBefore);
+    });
   });
 
   describe("error handler", () => {
@@ -825,6 +1205,9 @@ describe("App", () => {
         { command: "bg", description: "Spawn a background agent" },
         { command: "sessions", description: "List running sessions" },
         { command: "clear", description: "Clear session and start fresh" },
+        { command: "chats", description: "List authorized chats (admin only)" },
+        { command: "chatsadd", description: "Authorize a new chat (admin only)" },
+        { command: "chatsremove", description: "Remove an authorized chat (admin only)" },
       ]);
     });
   });