macroclaw 0.45.0 → 0.47.0

package/src/app.ts

@@ -1,15 +1,19 @@
 import type { Bot } from "grammy";
+import { AuthorizedChats, DuplicateChatError, InvalidChatNameError, UnknownChatError } from "./authorized-chats";
 import { createLogger } from "./logger";
-import { type Claude, Orchestrator, type OrchestratorResponse } from "./orchestrator";
-import { Scheduler } from "./scheduler";
+import { type ButtonSpec, type Claude, Orchestrator, type OrchestratorResponse } from "./orchestrator";
+import { type MissedInfo, Scheduler } from "./scheduler";
+import { clearMainSession } from "./sessions";
 import type { SpeechToText } from "./speech-to-text";
 import { createBot, downloadFile, sendFile, sendResponse } from "./telegram";
 
 const log = createLogger("app");
 
+const ADMIN_CHAT_NAME = "admin";
+
 export interface AppConfig {
   botToken: string;
-  authorizedChatId: string;
+  adminChatId: string;
   workspace: string;
   model: string;
   timeZone: string;
@@ -17,25 +21,25 @@ export interface AppConfig {
   claude?: Claude;
   stt?: SpeechToText;
   healthCheckInterval?: number;
+  /** Injected for tests. If omitted, a fresh AuthorizedChats is constructed from settingsDir. */
+  authorizedChats?: AuthorizedChats;
 }
 
 export class App {
   #bot: Bot;
-  #orchestrator: Orchestrator;
   #config: AppConfig;
+  #authorizedChats: AuthorizedChats;
+  #orchestrators = new Map<string, Orchestrator>();
 
   constructor(config: AppConfig) {
     this.#config = config;
     this.#bot = createBot(config.botToken);
-    this.#orchestrator = new Orchestrator({
-      model: config.model,
-      workspace: config.workspace,
-      timeZone: config.timeZone,
-      settingsDir: config.settingsDir,
-      claude: config.claude,
-      healthCheckInterval: config.healthCheckInterval,
-      onResponse: (r) => this.#deliverResponse(r),
-    });
+    this.#authorizedChats = config.authorizedChats ?? new AuthorizedChats(config.settingsDir);
+
+    this.#createOrchestrator(ADMIN_CHAT_NAME, config.adminChatId);
+    for (const chat of this.#authorizedChats.list()) {
+      this.#createOrchestrator(chat.name, chat.chatId);
+    }
 
     this.#setupHandlers();
   }
@@ -45,14 +49,33 @@ export class App {
   }
 
   async dispose(): Promise<void> {
-    await this.#orchestrator.dispose();
+    for (const orch of this.#orchestrators.values()) {
+      await orch.dispose();
+    }
+    this.#orchestrators.clear();
+  }
+
+  handleCron(name: string, prompt: string, model?: string, missed?: MissedInfo, chat?: string): void {
+    const chatName = chat ?? ADMIN_CHAT_NAME;
+    if (chatName === "*") {
+      for (const orch of this.#orchestrators.values()) {
+        orch.handleCron(name, prompt, model, missed);
+      }
+      return;
+    }
+    const orch = this.#orchestratorByName(chatName);
+    if (orch) {
+      orch.handleCron(name, prompt, model, missed);
+    } else {
+      log.warn({ chatName, jobName: name }, "Cron job targets unknown chat");
+    }
   }
 
   start() {
     log.info("Starting macroclaw...");
     const scheduler = new Scheduler(this.#config.workspace, {
       timeZone: this.#config.timeZone,
-      onJob: (name, prompt, model, missed) => this.#orchestrator.handleCron(name, prompt, model, missed),
+      onJob: (name, prompt, model, missed, chat) => this.handleCron(name, prompt, model, missed, chat),
     });
     scheduler.start();
     this.#bot.api.setMyCommands([
@@ -60,21 +83,77 @@ export class 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)" },
     ]).catch((err) => log.error({ err }, "Failed to set commands"));
     this.#bot.start({
       onStart: (botInfo) => {
-        log.info({ username: botInfo.username, chatId: this.#config.authorizedChatId }, "Bot connected");
+        log.info(
+          { username: botInfo.username, adminChatId: this.#config.adminChatId, authorizedChats: this.#authorizedChats.list().length },
+          "Bot connected",
+        );
       },
     });
   }
 
-  async #deliverResponse(response: OrchestratorResponse) {
+  #createOrchestrator(chatName: string, chatId: string): Orchestrator {
+    const orch = new Orchestrator({
+      chatName,
+      model: this.#config.model,
+      workspace: this.#config.workspace,
+      timeZone: this.#config.timeZone,
+      settingsDir: this.#config.settingsDir,
+      claude: this.#config.claude,
+      healthCheckInterval: this.#config.healthCheckInterval,
+      onResponse: (r) => this.#deliverResponse(chatId, r),
+    });
+    this.#orchestrators.set(chatId, orch);
+    return orch;
+  }
+
+  #orchestratorByName(chatName: string): Orchestrator | undefined {
+    if (chatName === ADMIN_CHAT_NAME) return this.#orchestrators.get(this.#config.adminChatId);
+    const chat = this.#authorizedChats.byName(chatName);
+    if (!chat) return undefined;
+    return this.#orchestrators.get(chat.chatId);
+  }
+
+  #isAdminChat(chatId: number | string): boolean {
+    return chatId.toString() === this.#config.adminChatId;
+  }
+
+  async #removeChatByName(name: string, replyChatId: string): Promise<void> {
+    try {
+      const chat = this.#authorizedChats.remove(name);
+      const orch = this.#orchestrators.get(chat.chatId);
+      if (orch) {
+        await orch.dispose();
+        this.#orchestrators.delete(chat.chatId);
+      }
+      clearMainSession(name, this.#config.settingsDir);
+      log.info({ chatId: chat.chatId, name }, "Authorized chat removed");
+      sendResponse(this.#bot, replyChatId, `Chat "${name}" removed.`);
+    } catch (err) {
+      if (err instanceof UnknownChatError) {
+        sendResponse(this.#bot, replyChatId, `Error: ${err.message}`);
+      } else {
+        throw err;
+      }
+    }
+  }
+
+  #resolveOrchestrator(chatId: number | string): Orchestrator | undefined {
+    return this.#orchestrators.get(chatId.toString());
+  }
+
+  async #deliverResponse(chatId: string, response: OrchestratorResponse) {
     if (response.files?.length) {
       for (const filePath of response.files) {
-        await sendFile(this.#bot, this.#config.authorizedChatId, filePath);
+        await sendFile(this.#bot, chatId, filePath);
       }
     }
-    await sendResponse(this.#bot, this.#config.authorizedChatId, response.message, response.buttons);
+    await sendResponse(this.#bot, chatId, response.message, response.buttons);
   }
 
   #setupHandlers() {
@@ -84,73 +163,151 @@ export class App {
     });
 
     this.#bot.command("bg", (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
       const prompt = ctx.match?.trim();
       if (!prompt) {
         log.debug("Command /bg without prompt");
-        sendResponse(this.#bot, this.#config.authorizedChatId, "Usage: /bg &lt;prompt&gt;");
+        sendResponse(this.#bot, ctx.chat.id.toString(), "Usage: /bg &lt;prompt&gt;");
         return;
       }
       log.debug({ prompt }, "Command /bg spawn");
-      this.#orchestrator.handleBackgroundCommand(prompt);
+      orch.handleBackgroundCommand(prompt);
     });
 
     this.#bot.command("sessions", (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
       log.debug("Command /sessions");
-      this.#orchestrator.handleSessions();
+      orch.handleSessions();
     });
 
     this.#bot.command("clear", (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
       log.debug("Command /clear");
-      this.#orchestrator.handleClear();
+      orch.handleClear();
+    });
+
+    this.#bot.command("chats", (ctx) => {
+      if (!this.#isAdminChat(ctx.chat.id)) return;
+      log.debug("Command /chats");
+      const chatIdStr = ctx.chat.id.toString();
+      const chats = this.#authorizedChats.list();
+      if (chats.length === 0) {
+        sendResponse(this.#bot, chatIdStr, "No authorized chats.");
+        return;
+      }
+      const lines = chats.map((c) => `- ${c.name} (${c.chatId})`).join("\n");
+      sendResponse(this.#bot, chatIdStr, `Authorized chats:\n${lines}`);
+    });
+
+    this.#bot.command("chatsadd", (ctx) => {
+      if (!this.#isAdminChat(ctx.chat.id)) return;
+      log.debug("Command /chatsadd");
+      const chatIdStr = ctx.chat.id.toString();
+      const args = ctx.match?.trim().split(/\s+/);
+      if (!args || args.length < 2 || !args[0] || !args[1]) {
+        sendResponse(this.#bot, chatIdStr, "Usage: /chatsadd &lt;chatId&gt; &lt;name&gt;");
+        return;
+      }
+      const [newChatId, name] = args;
+      if (newChatId === this.#config.adminChatId) {
+        sendResponse(this.#bot, chatIdStr, "Error: chatId is already the admin chat");
+        return;
+      }
+      try {
+        const chat = this.#authorizedChats.add(newChatId, name);
+        this.#createOrchestrator(chat.name, chat.chatId);
+        log.info({ chatId: chat.chatId, name: chat.name }, "Authorized chat added");
+        sendResponse(this.#bot, chatIdStr, `Chat "${chat.name}" (${chat.chatId}) authorized.`);
+      } catch (err) {
+        if (err instanceof DuplicateChatError || err instanceof InvalidChatNameError) {
+          sendResponse(this.#bot, chatIdStr, `Error: ${err.message}`);
+        } else {
+          throw err;
+        }
+      }
+    });
+
+    this.#bot.command("chatsremove", async (ctx) => {
+      log.debug("Command /chatsremove");
+      const chatIdStr = ctx.chat.id.toString();
+      const name = ctx.match?.trim();
+      const isAdmin = this.#isAdminChat(ctx.chat.id);
+
+      if (!name) {
+        if (!isAdmin) {
+          // Non-admin chat with no arg: self-removal
+          const self = this.#authorizedChats.byChatId(chatIdStr);
+          if (!self) return;
+          await this.#removeChatByName(self.name, chatIdStr);
+          return;
+        }
+        const chats = this.#authorizedChats.list();
+        if (chats.length === 0) {
+          sendResponse(this.#bot, chatIdStr, "No authorized chats to remove.");
+          return;
+        }
+        const buttons: ButtonSpec[] = chats.map((c) => ({ text: c.name, data: `chatsremove:${c.name}` }));
+        buttons.push({ text: "Dismiss", data: "_dismiss" });
+        sendResponse(this.#bot, chatIdStr, "Which chat to remove?", buttons);
+        return;
+      }
+
+      // With explicit name: admin only
+      if (!isAdmin) return;
+      await this.#removeChatByName(name, chatIdStr);
     });
 
     this.#bot.on("message:photo", async (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
       const photos = ctx.message.photo;
       const largest = photos[photos.length - 1];
       try {
         const path = await downloadFile(this.#bot, largest.file_id, this.#config.botToken, "photo.jpg");
-        this.#orchestrator.handleMessage(ctx.message.caption ?? "", [path]);
+        orch.handleMessage(ctx.message.caption ?? "", [path]);
       } catch (err) {
         log.error({ err }, "Photo download failed");
-        this.#orchestrator.handleMessage(`[File download failed: photo.jpg]\n${ctx.message.caption ?? ""}`);
+        orch.handleMessage(`[File download failed: photo.jpg]\n${ctx.message.caption ?? ""}`);
       }
     });
 
     this.#bot.on("message:document", async (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
       const doc = ctx.message.document;
       const name = doc.file_name ?? "file";
       try {
         const path = await downloadFile(this.#bot, doc.file_id, this.#config.botToken, name);
-        this.#orchestrator.handleMessage(ctx.message.caption ?? "", [path]);
+        orch.handleMessage(ctx.message.caption ?? "", [path]);
       } catch (err) {
         log.error({ err }, "Document download failed");
-        this.#orchestrator.handleMessage(`[File download failed: ${name}]\n${ctx.message.caption ?? ""}`);
+        orch.handleMessage(`[File download failed: ${name}]\n${ctx.message.caption ?? ""}`);
       }
     });
 
     this.#bot.on("message:voice", async (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) return;
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) return;
+      const chatIdStr = ctx.chat.id.toString();
       if (!this.#config.stt) {
-        await sendResponse(this.#bot, this.#config.authorizedChatId, "[Voice messages not available — set openaiApiKey in settings to enable]");
+        await sendResponse(this.#bot, chatIdStr, "[Voice messages not available — set openaiApiKey in settings to enable]");
         return;
       }
       try {
         const path = await downloadFile(this.#bot, ctx.message.voice.file_id, this.#config.botToken, "voice.ogg");
         const text = await this.#config.stt.transcribe(path);
         if (!text.trim()) {
-          await sendResponse(this.#bot, this.#config.authorizedChatId, "[Could not understand audio]");
+          await sendResponse(this.#bot, chatIdStr, "[Could not understand audio]");
           return;
         }
-        await sendResponse(this.#bot, this.#config.authorizedChatId, `[Received audio]: ${text}`);
-        this.#orchestrator.handleMessage(text);
+        await sendResponse(this.#bot, chatIdStr, `[Received audio]: ${text}`);
+        orch.handleMessage(text);
       } catch (err) {
         log.error({ err }, "Voice transcription failed");
-        await sendResponse(this.#bot, this.#config.authorizedChatId, "[Failed to transcribe audio]");
+        await sendResponse(this.#bot, chatIdStr, "[Failed to transcribe audio]");
       }
     });
 
@@ -158,7 +315,11 @@ export class App {
       await ctx.answerCallbackQuery();
       const data = ctx.callbackQuery.data;
       if (data === "_noop") return;
-      if (ctx.chat?.id.toString() !== this.#config.authorizedChatId) return;
+
+      const chatId = ctx.chat?.id;
+      if (chatId === undefined) return;
+      const orch = this.#resolveOrchestrator(chatId);
+      if (!orch) return;
 
       if (data === "_dismiss") {
         await ctx.editMessageReplyMarkup({ reply_markup: undefined });
@@ -169,7 +330,7 @@ export class App {
         const sessionId = data.slice(7);
         await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [[{ text: "✓ Opened", callback_data: "_noop" }]] } });
         log.debug({ sessionId }, "Detail requested");
-        this.#orchestrator.handleDetail(sessionId);
+        orch.handleDetail(sessionId);
         return;
       }
 
@@ -177,7 +338,7 @@ export class App {
         const sessionId = data.slice(5);
         await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [[{ text: "✓ Peeked", callback_data: "_noop" }]] } });
         log.debug({ sessionId }, "Peek requested");
-        this.#orchestrator.handlePeek(sessionId);
+        orch.handlePeek(sessionId);
         return;
       }
 
@@ -185,22 +346,32 @@ export class App {
         const sessionId = data.slice(5);
         await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [[{ text: "✓ Killed", callback_data: "_noop" }]] } });
         log.debug({ sessionId }, "Kill requested");
-        this.#orchestrator.handleKill(sessionId);
+        orch.handleKill(sessionId);
+        return;
+      }
+
+      if (data.startsWith("chatsremove:")) {
+        if (!this.#isAdminChat(chatId)) return;
+        const name = data.slice("chatsremove:".length);
+        await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [[{ text: `✓ Removed ${name}`, callback_data: "_noop" }]] } });
+        log.debug({ name }, "Chat removal requested via button");
+        await this.#removeChatByName(name, chatId.toString());
         return;
       }
 
       await ctx.editMessageReplyMarkup({ reply_markup: { inline_keyboard: [[{ text: `✓ ${data}`, callback_data: "_noop" }]] } });
       log.debug({ label: data }, "Button clicked");
-      this.#orchestrator.handleButton(data);
+      orch.handleButton(data);
     });
 
     this.#bot.on("message:text", (ctx) => {
-      if (ctx.chat.id.toString() !== this.#config.authorizedChatId) {
+      const orch = this.#resolveOrchestrator(ctx.chat.id);
+      if (!orch) {
         log.debug({ chatId: ctx.chat.id }, "Unauthorized message");
         return;
       }
 
-      this.#orchestrator.handleMessage(ctx.message.text);
+      orch.handleMessage(ctx.message.text);
     });
 
     this.#bot.catch((err) => {

package/src/authorized-chats.test.ts

@@ -0,0 +1,196 @@
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import {
+  AuthorizedChats,
+  DuplicateChatError,
+  InvalidChatNameError,
+  UnknownChatError,
+} from "./authorized-chats";
+
+const tmpDir = "/tmp/macroclaw-authorized-chats-test";
+
+function cleanup() {
+  if (existsSync(tmpDir)) rmSync(tmpDir, { recursive: true });
+}
+
+beforeEach(cleanup);
+afterEach(cleanup);
+
+describe("AuthorizedChats.list", () => {
+  it("returns empty array when file does not exist", () => {
+    expect(new AuthorizedChats(tmpDir).list()).toEqual([]);
+  });
+
+  it("reads chats from file", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(
+      join(tmpDir, "authorized-chats.json"),
+      JSON.stringify({
+        chats: [
+          { chatId: "-1001", name: "family", addedAt: "2026-04-20T14:00:00.000Z" },
+          { chatId: "987", name: "work", addedAt: "2026-04-21T09:30:00.000Z" },
+        ],
+      }),
+    );
+    expect(new AuthorizedChats(tmpDir).list()).toEqual([
+      { chatId: "-1001", name: "family", addedAt: "2026-04-20T14:00:00.000Z" },
+      { chatId: "987", name: "work", addedAt: "2026-04-21T09:30:00.000Z" },
+    ]);
+  });
+
+  it("returns empty array when file is corrupt", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "authorized-chats.json"), "not json");
+    expect(new AuthorizedChats(tmpDir).list()).toEqual([]);
+  });
+
+  it("returns empty array when schema validation fails", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(
+      join(tmpDir, "authorized-chats.json"),
+      JSON.stringify({ chats: [{ chatId: "not-numeric", name: "x", addedAt: "now" }] }),
+    );
+    expect(new AuthorizedChats(tmpDir).list()).toEqual([]);
+  });
+
+  it("defaults to empty chats when field is missing", () => {
+    mkdirSync(tmpDir, { recursive: true });
+    writeFileSync(join(tmpDir, "authorized-chats.json"), JSON.stringify({}));
+    expect(new AuthorizedChats(tmpDir).list()).toEqual([]);
+  });
+});
+
+describe("AuthorizedChats.add", () => {
+  it("persists new chat to disk", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    const now = new Date("2026-04-20T14:00:00.000Z");
+    chats.add("12345", "family", now);
+    const raw = JSON.parse(readFileSync(join(tmpDir, "authorized-chats.json"), "utf-8"));
+    expect(raw).toEqual({
+      chats: [{ chatId: "12345", name: "family", addedAt: "2026-04-20T14:00:00.000Z" }],
+    });
+  });
+
+  it("uses current time by default", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    const chat = chats.add("12345", "family");
+    expect(chat.addedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+  });
+
+  it("returns the added chat", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    const chat = chats.add("12345", "family", new Date("2026-01-01T00:00:00.000Z"));
+    expect(chat).toEqual({ chatId: "12345", name: "family", addedAt: "2026-01-01T00:00:00.000Z" });
+  });
+
+  it("rejects duplicate name", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    chats.add("111", "family");
+    expect(() => chats.add("222", "family")).toThrow(DuplicateChatError);
+  });
+
+  it("rejects duplicate chatId", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    chats.add("111", "family");
+    expect(() => chats.add("111", "work")).toThrow(DuplicateChatError);
+  });
+
+  it("rejects reserved name 'admin'", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    expect(() => chats.add("111", "admin")).toThrow(InvalidChatNameError);
+  });
+
+  it("rejects invalid name format", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    expect(() => chats.add("111", "Family")).toThrow(InvalidChatNameError);
+    expect(() => chats.add("111", "with space")).toThrow(InvalidChatNameError);
+    expect(() => chats.add("111", "")).toThrow(InvalidChatNameError);
+  });
+
+  it("accepts valid names with digits and dashes", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    expect(() => chats.add("111", "family-1")).not.toThrow();
+    expect(() => chats.add("222", "project2")).not.toThrow();
+  });
+});
+
+describe("AuthorizedChats.remove", () => {
+  it("removes chat and persists", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    chats.add("111", "family");
+    chats.add("222", "work");
+    chats.remove("family");
+    expect(chats.list().map((c) => c.name)).toEqual(["work"]);
+
+    // Re-load from disk to confirm persistence
+    const reloaded = new AuthorizedChats(tmpDir);
+    expect(reloaded.list().map((c) => c.name)).toEqual(["work"]);
+  });
+
+  it("returns the removed chat", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    const added = chats.add("111", "family");
+    const removed = chats.remove("family");
+    expect(removed).toEqual(added);
+  });
+
+  it("throws UnknownChatError for missing name", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    expect(() => chats.remove("nonexistent")).toThrow(UnknownChatError);
+  });
+});
+
+describe("AuthorizedChats.byName / byChatId", () => {
+  it("byName finds a chat", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    chats.add("111", "family");
+    expect(chats.byName("family")?.chatId).toBe("111");
+    expect(chats.byName("unknown")).toBeUndefined();
+  });
+
+  it("byChatId finds a chat", () => {
+    const chats = new AuthorizedChats(tmpDir);
+    chats.add("111", "family");
+    expect(chats.byChatId("111")?.name).toBe("family");
+    expect(chats.byChatId("999")).toBeUndefined();
+  });
+});
+
+describe("AuthorizedChats.validateName", () => {
+  it("throws for 'admin'", () => {
+    expect(() => AuthorizedChats.validateName("admin")).toThrow(InvalidChatNameError);
+  });
+
+  it("throws for invalid characters", () => {
+    expect(() => AuthorizedChats.validateName("Capital")).toThrow(InvalidChatNameError);
+    expect(() => AuthorizedChats.validateName("with_underscore")).toThrow(InvalidChatNameError);
+  });
+
+  it("accepts valid names", () => {
+    expect(() => AuthorizedChats.validateName("family")).not.toThrow();
+    expect(() => AuthorizedChats.validateName("a-b-c")).not.toThrow();
+    expect(() => AuthorizedChats.validateName("x123")).not.toThrow();
+  });
+});
+
+describe("errors", () => {
+  it("DuplicateChatError carries kind and value", () => {
+    const err = new DuplicateChatError("name", "family");
+    expect(err.kind).toBe("name");
+    expect(err.value).toBe("family");
+    expect(err.message).toContain("family");
+  });
+
+  it("UnknownChatError carries chatName", () => {
+    const err = new UnknownChatError("ghost");
+    expect(err.chatName).toBe("ghost");
+    expect(err.message).toContain("ghost");
+  });
+
+  it("InvalidChatNameError carries chatName", () => {
+    const err = new InvalidChatNameError("bad name", "contains space");
+    expect(err.chatName).toBe("bad name");
+    expect(err.message).toContain("bad name");
+  });
+});