@pmate/cli 0.24.9 → 0.24.10

package/dist/index.js

@@ -9071,7 +9071,7 @@ __export(index_exports, {
   parseCommandArgs: () => parseCommandArgs
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_fs21 = require("fs");
+var import_node_fs22 = require("fs");
 var import_node_path26 = __toESM(require("path"));
 var import_chalk4 = __toESM(require("chalk"));
 
@@ -16052,8 +16052,85 @@ function pad2(value) {
   return String(value).padStart(2, "0");
 }
 
-// src/commands/AgentCommandHandler.ts
+// src/commands/ChatRoomCommandHandler.ts
 var import_node_fs12 = require("fs");
+var ChatRoomCommandHandler = class {
+  async handle(args) {
+    const sdk = await loadChatSdk();
+    if (args.action === "smoke") {
+      await this.smoke(sdk, args);
+      return;
+    }
+    const client = await this.connect(sdk, args.bot, args.app, args.hubUrl, args.authBaseUrl);
+    try {
+      switch (args.action) {
+        case "join":
+          client.watchMessages((message) => ui.plain(JSON.stringify(message)));
+          ui.success("chat-room joined");
+          return;
+        case "request-friend":
+          await client.requestFriend({ to: args.to, message: args.message });
+          ui.success("friend request sent");
+          return;
+        case "accept-friend":
+          await client.acceptFriend({ to: args.to, requestId: args.requestId, message: args.message });
+          ui.success("friend request accepted");
+          return;
+        case "send":
+          await client.sendDm({ to: args.to, text: args.text });
+          ui.success("message sent");
+          return;
+        case "group-create":
+          await client.createGroup({ groupId: args.groupId, members: args.members, title: args.title });
+          ui.success("group created");
+          return;
+        case "group-send":
+          await client.sendGroup({ groupId: args.groupId, text: args.text, recipients: args.recipients });
+          ui.success("group message sent");
+          return;
+      }
+    } finally {
+      if (args.action !== "join") {
+        client.close();
+      }
+    }
+  }
+  async smoke(sdk, args) {
+    const a = await this.connect(sdk, args.botA, args.app, args.hubUrl, args.authBaseUrl);
+    const b = await this.connect(sdk, args.botB, args.app, args.hubUrl, args.authBaseUrl);
+    try {
+      const botA = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(args.botA, "utf8"));
+      const botB = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(args.botB, "utf8"));
+      await a.requestFriend({ to: botB.name, message: "smoke friend request" });
+      await b.acceptFriend({ to: botA.name, message: "smoke friend accept" });
+      await a.sendDm({ to: botB.name, text: "smoke dm from a" });
+      await b.sendDm({ to: botA.name, text: "smoke dm from b" });
+      const groupId = `smoke-${Date.now()}`;
+      await a.createGroup({ groupId, members: [botB.name], title: "Smoke Group" });
+      await a.sendGroup({ groupId, text: "smoke group message", recipients: [botB.name] });
+      ui.success("chat-room smoke passed");
+    } finally {
+      a.close();
+      b.close();
+    }
+  }
+  async connect(sdk, botPath, appId, hubUrl, authBaseUrl) {
+    if (!botPath) {
+      throw new Error("Missing required option: --bot");
+    }
+    const botKey = sdk.parsePmateBotKeyJson((0, import_node_fs12.readFileSync)(botPath, "utf8"));
+    const client = sdk.createChatClient({ appId, botKey, hubUrl, authBaseUrl });
+    await client.connect();
+    return client;
+  }
+};
+async function loadChatSdk() {
+  const dynamicImport = new Function("specifier", "return import(specifier)");
+  return await dynamicImport("@pmate/chat-sdk/runtime");
+}
+
+// src/commands/AgentCommandHandler.ts
+var import_node_fs13 = require("fs");
 var import_node_path17 = __toESM(require("path"));
 init_AgentLlmClient();
 init_sessionStore();
@@ -16521,10 +16598,10 @@ var AgentCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path17.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs12.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs12.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16619,7 +16696,7 @@ var AgentCommandHandler = class {
 };
 
 // src/commands/RunnerCommandHandler.ts
-var import_node_fs13 = require("fs");
+var import_node_fs14 = require("fs");
 var import_node_path18 = __toESM(require("path"));
 init_sessionStore();
 init_namespacedRef();
@@ -16716,10 +16793,10 @@ var RunnerCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path18.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs13.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs13.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -16838,7 +16915,7 @@ var NsCommandHandler = class {
 };
 
 // src/commands/StoreCommandHandler.ts
-var import_node_fs14 = require("fs");
+var import_node_fs15 = require("fs");
 var import_node_path19 = __toESM(require("path"));
 var StoreCommandHandler = class {
   async handle(args) {
@@ -16982,10 +17059,10 @@ var StoreCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path19.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs14.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs15.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs14.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs15.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17037,12 +17114,12 @@ var StoreCommandHandler = class {
 };
 
 // src/commands/AppCommandHandler.ts
-var import_node_fs16 = require("fs");
+var import_node_fs17 = require("fs");
 var import_node_path21 = __toESM(require("path"));
 init_sessionStore();
 
 // src/appIcon.ts
-var import_node_fs15 = require("fs");
+var import_node_fs16 = require("fs");
 var import_node_os7 = __toESM(require("os"));
 var import_node_path20 = __toESM(require("path"));
 var import_sharp = __toESM(require("sharp"));
@@ -17150,7 +17227,7 @@ function createAppIconExportPlans(input) {
       throw new Error("App icon preset export requires --out-dir.");
     }
     const outDir = import_node_path20.default.resolve(input.cwd, input.outDir);
-    (0, import_node_fs15.mkdirSync)(outDir, { recursive: true });
+    (0, import_node_fs16.mkdirSync)(outDir, { recursive: true });
     return specs.map((spec) => ({
       width: spec.width,
       height: spec.height,
@@ -17169,7 +17246,7 @@ function createAppIconExportPlans(input) {
     throw new Error("Single-size app icon export requires --output.");
   }
   const resolvedOutput = import_node_path20.default.resolve(input.cwd, input.output);
-  (0, import_node_fs15.mkdirSync)(import_node_path20.default.dirname(resolvedOutput), { recursive: true });
+  (0, import_node_fs16.mkdirSync)(import_node_path20.default.dirname(resolvedOutput), { recursive: true });
   return [
     {
       width: input.width,
@@ -17183,7 +17260,7 @@ async function exportAppIcon(icon, plans) {
   const svg = await resolveAppIconSvg(icon);
   for (const plan of plans) {
     const bytes = await renderAppIcon(svg, plan.width, plan.height, plan.format);
-    (0, import_node_fs15.writeFileSync)(plan.outputPath, bytes);
+    (0, import_node_fs16.writeFileSync)(plan.outputPath, bytes);
   }
 }
 async function renderAppIconVariant(input) {
@@ -17192,8 +17269,8 @@ async function renderAppIconVariant(input) {
   let outputPath;
   if (input.output) {
     outputPath = import_node_path20.default.resolve(input.cwd, input.output);
-    (0, import_node_fs15.mkdirSync)(import_node_path20.default.dirname(outputPath), { recursive: true });
-    (0, import_node_fs15.writeFileSync)(outputPath, bytes);
+    (0, import_node_fs16.mkdirSync)(import_node_path20.default.dirname(outputPath), { recursive: true });
+    (0, import_node_fs16.writeFileSync)(outputPath, bytes);
   }
   if (input.name) {
     return {
@@ -17223,7 +17300,7 @@ async function loadAppIconVariantFile(input) {
       name: input.name,
       format,
       sourcePath: absolutePath
-    }) : createImageDataUrl((0, import_node_fs15.readFileSync)(absolutePath), format),
+    }) : createImageDataUrl((0, import_node_fs16.readFileSync)(absolutePath), format),
     format,
     absolutePath
   };
@@ -17353,7 +17430,7 @@ async function uploadAppIconVariantAsset(input) {
     await AliyunService.uploadFile(sourcePath, DEFAULT_APP_ICON_VARIANT_BUCKET, objectKey);
   } finally {
     if (shouldCleanup) {
-      (0, import_node_fs15.rmSync)(import_node_path20.default.dirname(sourcePath), { recursive: true, force: true });
+      (0, import_node_fs16.rmSync)(import_node_path20.default.dirname(sourcePath), { recursive: true, force: true });
     }
   }
   return `${DEFAULT_APP_ICON_VARIANT_PUBLIC_BASE_URL}/${objectKey}`;
@@ -17398,9 +17475,9 @@ function writeTempAppIconVariantFile(objectKey, format, bytes) {
   if (!bytes) {
     throw new Error("App icon variant upload requires bytes or a source file.");
   }
-  const tempDir = (0, import_node_fs15.mkdtempSync)(import_node_path20.default.join(import_node_os7.default.tmpdir(), "pmate-app-icon-"));
+  const tempDir = (0, import_node_fs16.mkdtempSync)(import_node_path20.default.join(import_node_os7.default.tmpdir(), "pmate-app-icon-"));
   const tempPath = import_node_path20.default.join(tempDir, import_node_path20.default.basename(objectKey) || `variant.${extensionForIconFormat(format)}`);
-  (0, import_node_fs15.writeFileSync)(tempPath, bytes);
+  (0, import_node_fs16.writeFileSync)(tempPath, bytes);
   return tempPath;
 }
 
@@ -17609,10 +17686,10 @@ var AppCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs16.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs17.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs16.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs17.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -17742,13 +17819,13 @@ function readNamespaceFromPayload(payload) {
 }
 
 // src/commands/ServiceCommandHandler.ts
-var import_node_fs18 = require("fs");
+var import_node_fs19 = require("fs");
 var import_promises5 = require("fs/promises");
 var import_node_path23 = __toESM(require("path"));
 var import_promises6 = require("readline/promises");
 
 // src/services/ServiceRuntimeRunner.ts
-var import_node_fs17 = require("fs");
+var import_node_fs18 = require("fs");
 var import_node_os8 = __toESM(require("os"));
 var import_node_path22 = __toESM(require("path"));
 var import_node_child_process10 = require("child_process");
@@ -18137,7 +18214,7 @@ var ServiceRuntimeRunner = class {
           import_node_path22.default.join(import_node_os8.default.homedir(), "dev", "pmate-envs", repoName)
         ];
         for (const candidate of candidates) {
-          if ((0, import_node_fs17.existsSync)(candidate)) {
+          if ((0, import_node_fs18.existsSync)(candidate)) {
             return candidate;
           }
         }
@@ -18156,7 +18233,7 @@ var ServiceRuntimeRunner = class {
   async deployVite(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
     const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -18166,7 +18243,7 @@ var ServiceRuntimeRunner = class {
     }
     await this.runCommand("pnpm", ["--filter", pkgName, "build"], this.resolveRepoRoot(service, options.cwd));
     const distDir = import_node_path22.default.join(appDir, "dist");
-    if (!(0, import_node_fs17.existsSync)(distDir)) {
+    if (!(0, import_node_fs18.existsSync)(distDir)) {
       throw new Error(`No dist directory found at ${distDir}`);
     }
     const site = this.getSite(service);
@@ -18179,7 +18256,7 @@ var ServiceRuntimeRunner = class {
   async deployStatic(service, options) {
     const appDir = this.resolveLocalDir(service, options.cwd);
     const srcDir = import_node_path22.default.join(appDir, "src");
-    if (!(0, import_node_fs17.existsSync)(srcDir)) {
+    if (!(0, import_node_fs18.existsSync)(srcDir)) {
       throw new Error(`No src directory found at ${srcDir}`);
     }
     const site = this.getSite(service);
@@ -18195,7 +18272,7 @@ var ServiceRuntimeRunner = class {
     const repoRoot = this.resolveRepoRoot(service);
     const appDir = this.resolveLocalDir(service);
     const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
     const pkg2 = this.loadPackageJson(packageJsonPath);
@@ -18249,14 +18326,14 @@ var ServiceRuntimeRunner = class {
     const appDir = this.resolveLocalDir(service, options.cwd);
     await this.ensurePnpmWorkspaceRoot(repoRoot);
     const configPath = import_node_path22.default.join(appDir, fc.configFile ?? "s.yaml");
-    if (!(0, import_node_fs17.existsSync)(configPath)) {
+    if (!(0, import_node_fs18.existsSync)(configPath)) {
       throw new Error(`Missing FC config file at ${configPath}`);
     }
     const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-    if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+    if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
       throw new Error(`No package.json found at ${packageJsonPath}`);
     }
-    const rawConfig = (0, import_node_fs17.readFileSync)(configPath, "utf8");
+    const rawConfig = (0, import_node_fs18.readFileSync)(configPath, "utf8");
     if (!rawConfig.includes(fc.functionName)) {
       throw new Error(`FC config ${configPath} does not mention functionName ${fc.functionName}`);
     }
@@ -18444,7 +18521,7 @@ var ServiceRuntimeRunner = class {
       const serverAddress = await resolveServerAddress(server);
       const templateName = exposeType === "websocket" ? "nginx.ws.template" : "nginx.rest.template";
       const templatePath = this.resolveTemplatePath(templateName);
-      const template = (0, import_node_fs17.readFileSync)(templatePath, "utf8");
+      const template = (0, import_node_fs18.readFileSync)(templatePath, "utf8");
       const host = `${subdomain}.${("domain" in network ? network.domain?.trim() : void 0) || "pmate.chat"}`;
       const rendered = template.replace(/\$\{\{PORT\}\}/g, String(port)).replace(/\$\{\{HOSTS\}\}/g, host).replace(/\$\{\{HOST\}\}/g, host);
       const remotePath = `/etc/nginx/sites-enabled/${subdomain}.conf`;
@@ -18477,10 +18554,10 @@ var ServiceRuntimeRunner = class {
     if (config.ensurePackageJson) {
       const appDir = this.resolveLocalDir(service, options.cwd);
       const packageJsonPath = import_node_path22.default.join(appDir, "package.json");
-      if (!(0, import_node_fs17.existsSync)(packageJsonPath)) {
+      if (!(0, import_node_fs18.existsSync)(packageJsonPath)) {
         throw new Error(`Missing package.json at ${packageJsonPath}`);
       }
-      const pkgStat = (0, import_node_fs17.statSync)(packageJsonPath);
+      const pkgStat = (0, import_node_fs18.statSync)(packageJsonPath);
       if (!pkgStat.isFile()) {
         throw new Error(`package.json is not a file at ${packageJsonPath}`);
       }
@@ -18954,7 +19031,7 @@ var ServiceRuntimeRunner = class {
       import_node_path22.default.join(__dirname, "templates", templateName)
     ];
     for (const candidate of candidates) {
-      if ((0, import_node_fs17.existsSync)(candidate)) {
+      if ((0, import_node_fs18.existsSync)(candidate)) {
         return candidate;
       }
     }
@@ -18986,7 +19063,7 @@ var ServiceRuntimeRunner = class {
     });
   }
   loadPackageJson(packageJsonPath) {
-    const raw = (0, import_node_fs17.readFileSync)(packageJsonPath, "utf8");
+    const raw = (0, import_node_fs18.readFileSync)(packageJsonPath, "utf8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object") {
       throw new Error(`Invalid package.json at ${packageJsonPath}`);
@@ -18995,7 +19072,7 @@ var ServiceRuntimeRunner = class {
   }
   writePackageJson(packageJsonPath, data) {
     const serialized = JSON.stringify(data, null, 2);
-    (0, import_node_fs17.writeFileSync)(packageJsonPath, `${serialized}
+    (0, import_node_fs18.writeFileSync)(packageJsonPath, `${serialized}
 `, "utf8");
   }
   validateFcConfig(service, fc) {
@@ -19023,7 +19100,7 @@ var ServiceRuntimeRunner = class {
   }
   async ensurePnpmWorkspaceRoot(repoRoot) {
     const workspacePath = import_node_path22.default.join(repoRoot, "pnpm-workspace.yaml");
-    if (!(0, import_node_fs17.existsSync)(workspacePath)) {
+    if (!(0, import_node_fs18.existsSync)(workspacePath)) {
       throw new Error(`Missing pnpm-workspace.yaml at ${workspacePath}`);
     }
   }
@@ -19092,16 +19169,16 @@ var ServiceRuntimeRunner = class {
     if (!privateKeyPath) {
       throw new Error("Missing ssl.prv in ~/.pmate/config.yaml.");
     }
-    if (!(0, import_node_fs17.existsSync)(certificatePath)) {
+    if (!(0, import_node_fs18.existsSync)(certificatePath)) {
       throw new Error(`SSL certificate file not found: ${certificatePath}`);
     }
-    if (!(0, import_node_fs17.existsSync)(privateKeyPath)) {
+    if (!(0, import_node_fs18.existsSync)(privateKeyPath)) {
       throw new Error(`SSL private key file not found: ${privateKeyPath}`);
     }
     return {
       certName: host,
-      certificate: (0, import_node_fs17.readFileSync)(certificatePath, "utf8"),
-      privateKey: (0, import_node_fs17.readFileSync)(privateKeyPath, "utf8")
+      certificate: (0, import_node_fs18.readFileSync)(certificatePath, "utf8"),
+      privateKey: (0, import_node_fs18.readFileSync)(privateKeyPath, "utf8")
     };
   }
   resolveFcProtocol(fc, certConfig) {
@@ -19454,10 +19531,10 @@ var ServiceCommandHandler = class {
   }
   readJsonFile(filePath) {
     const absolutePath = import_node_path23.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs18.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs18.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
     try {
       return JSON.parse(raw);
     } catch (error) {
@@ -19839,7 +19916,7 @@ var RoleCommandHandler = class {
 };
 
 // src/commands/AccountCommandHandler.ts
-var import_node_fs19 = require("fs");
+var import_node_fs20 = require("fs");
 var import_node_crypto4 = require("crypto");
 var import_node_path24 = __toESM(require("path"));
 init_sessionStore();
@@ -19850,8 +19927,8 @@ var AccountCommandHandler = class {
         const keyFile = this.generateBotKeyFile(args.app, args.name);
         if (args.out) {
           const outPath = this.resolveFilePath(args.out);
-          (0, import_node_fs19.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
-          (0, import_node_fs19.chmodSync)(outPath, 384);
+          (0, import_node_fs20.writeFileSync)(outPath, JSON.stringify(keyFile, null, 2), { mode: 384 });
+          (0, import_node_fs20.chmodSync)(outPath, 384);
           if (!args.json) {
             ui.success(`Bot key saved to ${outPath}`);
           }
@@ -20296,10 +20373,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing visible apps input");
     }
     const absolutePath = this.resolveFilePath(args.filePath);
-    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs19.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -20333,10 +20410,10 @@ var AccountCommandHandler = class {
       throw new Error("Missing bot key file");
     }
     const absolutePath = this.resolveFilePath(filePath);
-    if (!(0, import_node_fs19.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
       throw new Error(`Bot key file not found: ${absolutePath}`);
     }
-    const parsed = JSON.parse((0, import_node_fs19.readFileSync)(absolutePath, "utf8"));
+    const parsed = JSON.parse((0, import_node_fs20.readFileSync)(absolutePath, "utf8"));
     if (parsed.type !== "pmate-bot-key" || parsed.version !== 1 || parsed.algorithm !== "ed25519" || !parsed.publicKey || !parsed.privateKey) {
       throw new Error(`Invalid PMate bot key file: ${absolutePath}`);
     }
@@ -20388,7 +20465,7 @@ function encodePathSegment(value) {
 }
 
 // src/commands/OrgCommandHandler.ts
-var import_node_fs20 = require("fs");
+var import_node_fs21 = require("fs");
 var import_node_path25 = __toESM(require("path"));
 init_sessionStore();
 var OrgCommandHandler = class {
@@ -20561,10 +20638,10 @@ var OrgCommandHandler = class {
       throw new Error(`Missing ${itemLabel} input`);
     }
     const absolutePath = import_node_path25.default.resolve(process.cwd(), filePath);
-    if (!(0, import_node_fs20.existsSync)(absolutePath)) {
+    if (!(0, import_node_fs21.existsSync)(absolutePath)) {
       throw new Error(`JSON file not found: ${absolutePath}`);
     }
-    const raw = (0, import_node_fs20.readFileSync)(absolutePath, "utf8");
+    const raw = (0, import_node_fs21.readFileSync)(absolutePath, "utf8");
     let parsed;
     try {
       parsed = JSON.parse(raw);
@@ -23252,6 +23329,135 @@ function requireValue10(tokens, optionName) {
   return value;
 }
 
+// src/chatRoomCommandParser.ts
+function parseChatRoomArgs(tokens) {
+  const rest = [...tokens];
+  const action = rest.shift();
+  if (!action) {
+    throw new Error("Usage: chat-room <join|request-friend|accept-friend|send|group-create|group-send|smoke>");
+  }
+  const parsed = parseShared(rest);
+  const { options, multiOptions, ...shared } = parsed;
+  switch (action) {
+    case "smoke":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        botA: requiredOption(options, "--bot-a"),
+        botB: requiredOption(options, "--bot-b"),
+        app: shared.app,
+        hubUrl: shared.hubUrl,
+        authBaseUrl: shared.authBaseUrl
+      };
+    case "join":
+      return { type: "chat-room" /* ChatRoom */, action, ...withBot(shared, options) };
+    case "request-friend":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        ...withBot(shared, options),
+        to: requiredOption(options, "--to"),
+        message: options.get("--message")
+      };
+    case "accept-friend":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        ...withBot(shared, options),
+        to: requiredOption(options, "--to"),
+        requestId: options.get("--request-id"),
+        message: options.get("--message")
+      };
+    case "send":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        ...withBot(shared, options),
+        to: requiredOption(options, "--to"),
+        text: requiredOption(options, "--text")
+      };
+    case "group-create":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        ...withBot(shared, options),
+        groupId: requiredOption(options, "--group"),
+        members: multiOptions.get("--member") ?? [],
+        title: options.get("--title")
+      };
+    case "group-send":
+      return {
+        type: "chat-room" /* ChatRoom */,
+        action,
+        ...withBot(shared, options),
+        groupId: requiredOption(options, "--group"),
+        text: requiredOption(options, "--text"),
+        recipients: multiOptions.get("--recipient")
+      };
+    default:
+      throw new Error(`Unknown chat-room action: ${action}`);
+  }
+}
+function withBot(shared, options) {
+  return { ...shared, bot: requiredOption(options, "--bot") };
+}
+function parseShared(tokens) {
+  const options = /* @__PURE__ */ new Map();
+  const multiOptions = /* @__PURE__ */ new Map();
+  while (tokens.length > 0) {
+    const token = tokens.shift();
+    switch (token) {
+      case "--bot":
+      case "--app":
+      case "--hub-url":
+      case "--auth-base-url":
+      case "--to":
+      case "--message":
+      case "--request-id":
+      case "--text":
+      case "--group":
+      case "--title":
+      case "--bot-a":
+      case "--bot-b":
+        options.set(token, requireValue11(tokens, token));
+        break;
+      case "--member":
+      case "--recipient": {
+        const values = multiOptions.get(token) ?? [];
+        values.push(requireValue11(tokens, token));
+        multiOptions.set(token, values);
+        break;
+      }
+      default:
+        throw new Error(`Unknown chat-room option: ${token}`);
+    }
+  }
+  const app = requiredOption(options, "--app");
+  const bot = options.get("--bot");
+  return {
+    bot,
+    app,
+    hubUrl: options.get("--hub-url"),
+    authBaseUrl: options.get("--auth-base-url"),
+    options,
+    multiOptions
+  };
+}
+function requiredOption(options, option) {
+  const value = options.get(option);
+  if (!value) {
+    throw new Error(`Missing required option: ${option}`);
+  }
+  return value;
+}
+function requireValue11(tokens, option) {
+  const value = tokens.shift();
+  if (!value || value.startsWith("--")) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+}
+
 // src/prepareDevCommandParser.ts
 function parsePrepareDevArgs(tokens) {
   const rest = [...tokens];
@@ -23279,7 +23485,7 @@ function parsePrepareDevArgs(tokens) {
         close = true;
         break;
       case "--env": {
-        const rawValue = requireValue11(rest, token);
+        const rawValue = requireValue12(rest, token);
         const parsed = Number.parseInt(rawValue, 10);
         if (!Number.isInteger(parsed) || parsed < 0) {
           throw new Error(`Invalid --env value: ${rawValue}`);
@@ -23288,13 +23494,13 @@ function parsePrepareDevArgs(tokens) {
         break;
       }
       case "--env-root":
-        envRoot = requireValue11(rest, token);
+        envRoot = requireValue12(rest, token);
         break;
       case "--base-root":
-        baseRoot = requireValue11(rest, token);
+        baseRoot = requireValue12(rest, token);
         break;
       case "--note":
-        note = requireValue11(rest, token);
+        note = requireValue12(rest, token);
         break;
       case "--json":
         json = true;
@@ -23330,7 +23536,7 @@ function parsePrepareDevArgs(tokens) {
     json
   };
 }
-function requireValue11(tokens, option) {
+function requireValue12(tokens, option) {
   const value = tokens.shift();
   if (!value || value.startsWith("-")) {
     throw new Error(`Missing value for ${option}`);
@@ -23340,7 +23546,7 @@ function requireValue11(tokens, option) {
 
 // src/index.ts
 var pkg = JSON.parse(
-  (0, import_node_fs21.readFileSync)(import_node_path26.default.resolve(__dirname, "..", "package.json"), "utf8")
+  (0, import_node_fs22.readFileSync)(import_node_path26.default.resolve(__dirname, "..", "package.json"), "utf8")
 );
 var HELP_TEXT = [
   import_chalk4.default.bold(`pmate v${pkg.version}`),
@@ -23423,6 +23629,8 @@ var HELP_TEXT = [
   `  ${import_chalk4.default.gray("                  --easy [--words <n>] [--digits <n>] [--separator <s>] [--count <n>]")}`,
   `  ${import_chalk4.default.cyan("collect")}          Collect threads/messages from Electron chat app via CDP`,
   `  ${import_chalk4.default.gray("                  sync (--source <cc|yelling> | --endpoint <url>)")}`,
+  `  ${import_chalk4.default.cyan("chat-room")}        Run social chat regression commands with PMate bot key JSON`,
+  `  ${import_chalk4.default.gray("                  join|request-friend|accept-friend|send|group-create|group-send|smoke --app <ns:app> --bot <file>")}`,
   `  ${import_chalk4.default.cyan("agent")}            Manage agent registry entries and call agents for debugging`,
   `  ${import_chalk4.default.gray("                  namespaces [--base-url <url>] [--json]")}`,
   `  ${import_chalk4.default.gray("                  list [--namespace <ns>] [--base-url <url>] [--json]")}`,
@@ -23578,7 +23786,7 @@ function parseCommandArgs(args) {
       const token = rest.shift();
       switch (token) {
         case "--app":
-          app = requireValue12(rest, token);
+          app = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown login option: ${token}`);
@@ -23640,6 +23848,9 @@ function parseCommandArgs(args) {
   if (args.rest[0] === "collect") {
     return parseCollectArgs(args.rest.slice(1));
   }
+  if (args.rest[0] === "chat-room") {
+    return parseChatRoomArgs(args.rest.slice(1));
+  }
   if (args.rest[0] === "agent") {
     return parseAgentArgs(args.rest.slice(1));
   }
@@ -23684,7 +23895,7 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue12(rest, token);
+          scope = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown vercel option: ${token}`);
@@ -23704,10 +23915,10 @@ function parseVercelArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--scope":
-          scope = requireValue12(rest, token);
+          scope = requireValue13(rest, token);
           break;
         case "--project":
-          project = requireValue12(rest, token);
+          project = requireValue13(rest, token);
           break;
         case "--last-week":
           lastWeek = true;
@@ -23738,16 +23949,16 @@ function parseAddDnsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--type":
-        options.dnsType = requireValue12(rest, token);
+        options.dnsType = requireValue13(rest, token);
         break;
       case "--value":
-        options.dnsValue = requireValue12(rest, token);
+        options.dnsValue = requireValue13(rest, token);
         break;
       case "--rr":
-        options.dnsRr = requireValue12(rest, token);
+        options.dnsRr = requireValue13(rest, token);
         break;
       case "--ttl": {
-        const ttlValue = requireValue12(rest, token);
+        const ttlValue = requireValue13(rest, token);
         const ttl = Number.parseInt(ttlValue, 10);
         if (!Number.isFinite(ttl) || ttl <= 0) {
           throw new Error(`Invalid --ttl value: ${ttlValue}`);
@@ -23756,7 +23967,7 @@ function parseAddDnsArgs(tokens) {
         break;
       }
       case "--domain":
-        options.dnsDomain = requireValue12(rest, token);
+        options.dnsDomain = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown add-dns option: ${token}`);
@@ -23789,13 +24000,13 @@ function parseBucketArgs(tokens) {
         options.bucketCreate = true;
         break;
       case "--name":
-        options.bucketName = requireValue12(rest, token);
+        options.bucketName = requireValue13(rest, token);
         break;
       case "--subdomain":
-        options.bucketSubdomain = requireValue12(rest, token);
+        options.bucketSubdomain = requireValue13(rest, token);
         break;
       case "--domain":
-        options.bucketDomain = requireValue12(rest, token);
+        options.bucketDomain = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown bucket option: ${token}`);
@@ -23827,7 +24038,7 @@ function parseDevArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        options.devCwd = requireValue12(rest, token);
+        options.devCwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown dev option: ${token}`);
@@ -23847,7 +24058,7 @@ function parseDeleteArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--cwd":
-        deleteCwd = requireValue12(rest, token);
+        deleteCwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown delete option: ${token}`);
@@ -23881,13 +24092,13 @@ function parseOssArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--bucket":
-        bucket = requireValue12(rest, token);
+        bucket = requireValue13(rest, token);
         break;
       case "--file":
-        filePath = requireValue12(rest, token);
+        filePath = requireValue13(rest, token);
         break;
       case "--key":
-        objectKey = requireValue12(rest, token);
+        objectKey = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown oss option: ${token}`);
@@ -23920,7 +24131,7 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "set";
-        key = requireValue12(rest, token);
+        key = requireValue13(rest, token);
         break;
       case "--list":
         if (action) {
@@ -23933,17 +24144,17 @@ function parseEnvArgs(tokens) {
           throw new Error("Only one env action is allowed.");
         }
         action = "delete";
-        key = requireValue12(rest, token);
+        key = requireValue13(rest, token);
         break;
       case "--value":
-        value = requireValue12(rest, token);
+        value = requireValue13(rest, token);
         break;
       case "--verbose":
       case "-v":
         verbose = true;
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown env option: ${token}`);
@@ -24001,7 +24212,7 @@ function parseCommitArgs(tokens) {
         push = true;
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown commit option: ${token}`);
@@ -24017,10 +24228,10 @@ function parseSummaryArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--pr":
-        prRef = requireValue12(rest, token);
+        prRef = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown summary option: ${token}`);
@@ -24045,13 +24256,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz create-draft option: ${token}`);
@@ -24077,16 +24288,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--file":
-          filePath = requireValue12(rest, token);
+          filePath = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz update-meta option: ${token}`);
@@ -24116,16 +24327,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--file":
-          filePath = requireValue12(rest, token);
+          filePath = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz append-step option: ${token}`);
@@ -24156,19 +24367,19 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--step-id":
-          stepId = requireValue12(rest, token);
+          stepId = requireValue13(rest, token);
           break;
         case "--file":
-          filePath = requireValue12(rest, token);
+          filePath = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz update-step option: ${token}`);
@@ -24202,16 +24413,16 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--step-ids":
-          stepIdsRaw = requireValue12(rest, token);
+          stepIdsRaw = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz reorder option: ${token}`);
@@ -24244,13 +24455,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz activate option: ${token}`);
@@ -24275,13 +24486,13 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown quiz view option: ${token}`);
@@ -24310,22 +24521,22 @@ function parseQuizArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--paper-id":
-          paperId = requireValue12(rest, token);
+          paperId = requireValue13(rest, token);
           break;
         case "--step-id":
-          stepId = requireValue12(rest, token);
+          stepId = requireValue13(rest, token);
           break;
         case "--file":
-          filePath = requireValue12(rest, token);
+          filePath = requireValue13(rest, token);
           break;
         case "--new-paper-id":
-          newPaperId = requireValue12(rest, token);
+          newPaperId = requireValue13(rest, token);
           break;
         case "--base-url":
-          apiBaseUrl = requireValue12(rest, token);
+          apiBaseUrl = requireValue13(rest, token);
           break;
         case "--link-base":
-          linkBaseUrl = requireValue12(rest, token);
+          linkBaseUrl = requireValue13(rest, token);
           break;
         case "--activate":
           activate = true;
@@ -24415,10 +24626,10 @@ function parseLinearPrArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24447,35 +24658,35 @@ function parseLinearCreateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--repl":
         useRepl = true;
         break;
       case "--title":
-        title = requireValue12(rest, token);
+        title = requireValue13(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue12(rest, token));
+        description = decodeEscapedNewlines(requireValue13(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue12(rest, token);
+        teamId = requireValue13(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue12(rest, token);
+        teamKey = requireValue13(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue12(rest, token));
+        priority = parseLinearPriority(requireValue13(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue12(rest, token);
+        parentId = requireValue13(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue12(rest, token);
+        stateId = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24510,10 +24721,10 @@ function parseLinearWhoamiArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24538,10 +24749,10 @@ function parseLinearViewArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24576,32 +24787,32 @@ function parseLinearUpdateArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--title":
-        title = requireValue12(rest, token);
+        title = requireValue13(rest, token);
         break;
       case "--desc":
       case "--description":
-        description = decodeEscapedNewlines(requireValue12(rest, token));
+        description = decodeEscapedNewlines(requireValue13(rest, token));
         break;
       case "--team-id":
-        teamId = requireValue12(rest, token);
+        teamId = requireValue13(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue12(rest, token);
+        teamKey = requireValue13(rest, token);
         break;
       case "--priority":
-        priority = parseLinearPriority(requireValue12(rest, token));
+        priority = parseLinearPriority(requireValue13(rest, token));
         break;
       case "--parent-id":
-        parentId = requireValue12(rest, token);
+        parentId = requireValue13(rest, token);
         break;
       case "--state-id":
-        stateId = requireValue12(rest, token);
+        stateId = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24639,10 +24850,10 @@ function parseLinearSubIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24669,15 +24880,15 @@ function parseLinearCommentArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--body":
       case "--desc":
       case "--description":
-        body = decodeEscapedNewlines(requireValue12(rest, token));
+        body = decodeEscapedNewlines(requireValue13(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24707,10 +24918,10 @@ function parseLinearCommentsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24734,16 +24945,16 @@ function parseLinearCycleArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue12(rest, token);
+        teamId = requireValue13(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue12(rest, token);
+        teamKey = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24766,10 +24977,10 @@ function parseLinearTeamsArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24796,16 +25007,16 @@ function parseLinearUserIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue12(rest, token));
+        cycle = parseLinearCycle(requireValue13(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue12(rest, token));
+        status = parseLinearStatus(requireValue13(rest, token));
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24839,28 +25050,28 @@ function parseLinearIssuesArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--team-id":
-        teamId = requireValue12(rest, token);
+        teamId = requireValue13(rest, token);
         break;
       case "--team-key":
-        teamKey = requireValue12(rest, token);
+        teamKey = requireValue13(rest, token);
         break;
       case "--user":
-        user = requireValue12(rest, token);
+        user = requireValue13(rest, token);
         break;
       case "--cycle":
-        cycle = parseLinearCycle(requireValue12(rest, token));
+        cycle = parseLinearCycle(requireValue13(rest, token));
         break;
       case "--status":
-        status = parseLinearStatus(requireValue12(rest, token));
+        status = parseLinearStatus(requireValue13(rest, token));
         break;
       case "--query":
-        query = requireValue12(rest, token).trim();
+        query = requireValue13(rest, token).trim();
         break;
       case "--limit": {
-        const value = Number.parseInt(requireValue12(rest, token), 10);
+        const value = Number.parseInt(requireValue13(rest, token), 10);
         if (!Number.isInteger(value) || value < 1 || value > 250) {
           throw new Error("Invalid --limit. Expected an integer between 1 and 250.");
         }
@@ -24868,7 +25079,7 @@ function parseLinearIssuesArgs(tokens) {
         break;
       }
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -24909,10 +25120,10 @@ function parseLinearLegacyArgs(tokens) {
         useScreenshot = true;
         break;
       case "--account":
-        account = requireValue12(rest, token);
+        account = requireValue13(rest, token);
         break;
       case "--cwd":
-        cwd = requireValue12(rest, token);
+        cwd = requireValue13(rest, token);
         break;
       default:
         throw new Error(`Unknown linear option: ${token}`);
@@ -25006,19 +25217,19 @@ function parseNotionArgs(tokens) {
       const token = rest.shift();
       switch (token) {
         case "--parent":
-          parentPageId = requireValue12(rest, token);
+          parentPageId = requireValue13(rest, token);
           break;
         case "--title":
-          title = requireValue12(rest, token);
+          title = requireValue13(rest, token);
           break;
         case "--private":
           isPrivate = true;
           break;
         case "--content":
-          content2 = requireValue12(rest, token);
+          content2 = requireValue13(rest, token);
           break;
         case "--file":
-          filePath2 = requireValue12(rest, token);
+          filePath2 = requireValue13(rest, token);
           break;
         default:
           throw new Error(`Unknown notion option: ${token}`);
@@ -25062,10 +25273,10 @@ function parseNotionArgs(tokens) {
     const token = rest.shift();
     switch (token) {
       case "--content":
-        content = requireValue12(rest, token);
+        content = requireValue13(rest, token);
         break;
       case "--file":
-        filePath = requireValue12(rest, token);
+        filePath = requireValue13(rest, token);
         break;
       case "--append":
         append = true;
@@ -25110,11 +25321,11 @@ function parseRandomArgs(tokens) {
         mode = "easy";
         break;
       case "--length":
-        length = parsePositiveInt2(requireValue12(rest, token), token);
+        length = parsePositiveInt2(requireValue13(rest, token), token);
         seenLength = true;
         break;
       case "--charset": {
-        const value = requireValue12(rest, token);
+        const value = requireValue13(rest, token);
         if (!["base64url", "hex", "alnum", "ascii"].includes(value)) {
           throw new Error(
             `Invalid --charset value: ${value}. Use base64url|hex|alnum|ascii.`
@@ -25125,18 +25336,18 @@ function parseRandomArgs(tokens) {
         break;
       }
       case "--count":
-        count = parsePositiveInt2(requireValue12(rest, token), token);
+        count = parsePositiveInt2(requireValue13(rest, token), token);
         break;
       case "--words":
-        words = parsePositiveInt2(requireValue12(rest, token), token);
+        words = parsePositiveInt2(requireValue13(rest, token), token);
         seenWords = true;
         break;
       case "--digits":
-        digits = parseNonNegativeInt(requireValue12(rest, token), token);
+        digits = parseNonNegativeInt(requireValue13(rest, token), token);
         seenDigits = true;
         break;
       case "--separator":
-        separator = requireValue12(rest, token);
+        separator = requireValue13(rest, token);
         seenSeparator = true;
         break;
       default:
@@ -25167,7 +25378,7 @@ function parseRandomArgs(tokens) {
     count
   };
 }
-function requireValue12(tokens, optionName) {
+function requireValue13(tokens, optionName) {
   const value = tokens.shift();
   if (!value) {
     throw new Error(`Missing value for ${optionName}`);
@@ -25298,6 +25509,11 @@ async function main() {
         await handler.handle(commandArgs);
         return;
       }
+      case "chat-room" /* ChatRoom */: {
+        const handler = new ChatRoomCommandHandler();
+        await handler.handle(commandArgs);
+        return;
+      }
       case "oss" /* Oss */: {
         const handler = new OssCommandHandler();
         await handler.handle(commandArgs);