@meet-ai/cli 0.0.20 → 0.0.22

package/dist/index.js

@@ -14690,6 +14690,21 @@ function createClient(baseUrl, apiKey) {
         return res.text();
       });
     },
+    async sendCommands(roomId, payload) {
+      return withRetry(async () => {
+        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/commands`, {
+          method: "POST",
+          headers: headers(),
+          body: payload
+        });
+        if (!res.ok) {
+          const err2 = await res.json().catch(() => ({}));
+          const msg = err2.error;
+          throw new Error(typeof msg === "string" ? msg : msg ? JSON.stringify(msg) : `HTTP ${res.status}`);
+        }
+        return res.text();
+      });
+    },
     async sendTasks(roomId, payload) {
       return withRetry(async () => {
         const res = await fetch(`${baseUrl}/api/rooms/${roomId}/tasks`, {
@@ -16803,10 +16818,10 @@ var init_command15 = __esm(() => {
 });
 
 // src/commands/setup-hooks/usecase.ts
-import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { existsSync as existsSync2 } from "node:fs";
-import { resolve as resolve2, dirname as dirname2 } from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
+import { resolve as resolve2, dirname as dirname2 } from "node:path";
 function isMeetAiHook(entry) {
   return entry.hooks?.some((h) => typeof h.command === "string" && h.command.startsWith("meet-ai hook ")) ?? false;
 }
@@ -16848,6 +16863,16 @@ function mergeHooks(existing) {
       }
     }
   }
+  for (const event of Object.keys(result)) {
+    const newMatchers = MEET_AI_HOOKS[event] ?? [];
+    result[event] = result[event].filter((m) => {
+      if (!isMeetAiHook(m))
+        return true;
+      return newMatchers.some((nm) => nm.matcher === m.matcher);
+    });
+    if (result[event].length === 0)
+      delete result[event];
+  }
   return { merged: result, added };
 }
 function removeHooks(existing) {
@@ -16938,7 +16963,7 @@ var init_usecase14 = __esm(() => {
           {
             type: "command",
             command: "meet-ai hook plan-review",
-            timeout: 2592000
+            timeout: 2147483
           }
         ]
       },
@@ -16953,7 +16978,7 @@ var init_usecase14 = __esm(() => {
         ]
       },
       {
-        matcher: ".*",
+        matcher: "^(?!ExitPlanMode$|AskUserQuestion$).*",
         hooks: [
           {
             type: "command",
@@ -17013,6 +17038,277 @@ var init_command16 = __esm(() => {
   });
 });
 
+// src/commands/list-commands/usecase.ts
+import { existsSync as existsSync3 } from "node:fs";
+import { readFile as readFile2, readdir } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join3, resolve as resolve3 } from "node:path";
+function parseYamlFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match)
+    return null;
+  const body = match[1];
+  const nameMatch = body.match(/^name:\s*(.+)$/m);
+  const descMatch = body.match(/^description:\s*(.+)$/m);
+  return {
+    name: nameMatch?.[1]?.trim(),
+    description: descMatch?.[1]?.trim()
+  };
+}
+async function readSkillsFromDir(baseDir, source, scope) {
+  const skillsDir = join3(baseDir, "skills");
+  if (!existsSync3(skillsDir))
+    return [];
+  let entries;
+  try {
+    entries = await readdir(skillsDir);
+  } catch {
+    return [];
+  }
+  const results = [];
+  for (const entry of entries) {
+    const skillFile = join3(skillsDir, entry, "SKILL.md");
+    if (!existsSync3(skillFile))
+      continue;
+    try {
+      const content = await readFile2(skillFile, "utf-8");
+      const fm = parseYamlFrontmatter(content);
+      if (!fm)
+        continue;
+      if (!fm.description)
+        continue;
+      results.push({
+        name: fm.name ?? entry,
+        description: fm.description,
+        type: "skill",
+        source,
+        scope
+      });
+    } catch {}
+  }
+  return results;
+}
+async function readCommandsFromDir(commandsDir, source, scope) {
+  if (!existsSync3(commandsDir))
+    return [];
+  const results = [];
+  async function scanDir(dir) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const fullPath = join3(dir, entry.name);
+      if (entry.isDirectory()) {
+        await scanDir(fullPath);
+      } else if (entry.isFile() && entry.name.endsWith(".md")) {
+        try {
+          const content = await readFile2(fullPath, "utf-8");
+          const fm = parseYamlFrontmatter(content);
+          if (!fm || !fm.description)
+            continue;
+          const fallbackName = entry.name.slice(0, -3);
+          results.push({
+            name: fm.name ?? fallbackName,
+            description: fm.description,
+            type: "command",
+            source,
+            scope
+          });
+        } catch {}
+      }
+    }
+  }
+  await scanDir(commandsDir);
+  return results;
+}
+async function readSettings2(settingsPath) {
+  if (!existsSync3(settingsPath))
+    return {};
+  try {
+    const raw = await readFile2(settingsPath, "utf-8");
+    return JSON.parse(raw.trim() || "{}");
+  } catch {
+    return {};
+  }
+}
+async function readInstalledPlugins(pluginsFile) {
+  if (!existsSync3(pluginsFile))
+    return {};
+  try {
+    const raw = await readFile2(pluginsFile, "utf-8");
+    const parsed = JSON.parse(raw);
+    return parsed.plugins ?? {};
+  } catch {
+    return {};
+  }
+}
+async function listCommands(options) {
+  const projectPath = resolve3(options.projectPath ?? process.cwd());
+  const userClaudeDir = options._userClaudeDir ?? join3(homedir3(), ".claude");
+  const pluginsFile = options._pluginsFile ?? join3(homedir3(), ".claude", "plugins", "installed_plugins.json");
+  const results = [];
+  for (const cmd of BUILT_IN_COMMANDS) {
+    results.push({ ...cmd, type: "command", source: "built-in", scope: "user" });
+  }
+  const userSkills = await readSkillsFromDir(userClaudeDir, "standalone", "user");
+  results.push(...userSkills);
+  const projectClaudeDir = join3(projectPath, ".claude");
+  const projectSkills = await readSkillsFromDir(projectClaudeDir, "standalone", "project");
+  results.push(...projectSkills);
+  const userSettings = await readSettings2(join3(userClaudeDir, "settings.json"));
+  const projectSettings = await readSettings2(join3(projectClaudeDir, "settings.json"));
+  const userEnabled = userSettings.enabledPlugins ?? {};
+  const projectEnabled = projectSettings.enabledPlugins ?? {};
+  const enabledPlugins = new Map;
+  for (const scopeName of Object.keys(userEnabled)) {
+    enabledPlugins.set(scopeName, "user");
+  }
+  for (const scopeName of Object.keys(projectEnabled)) {
+    enabledPlugins.set(scopeName, "project");
+  }
+  if (enabledPlugins.size > 0) {
+    const installedPlugins = await readInstalledPlugins(pluginsFile);
+    for (const [scopeName, pluginScope] of enabledPlugins) {
+      const installations = installedPlugins[scopeName];
+      if (!installations || installations.length === 0)
+        continue;
+      const { installPath } = installations[0];
+      const source = `plugin:${scopeName}`;
+      const pluginCommands = await readCommandsFromDir(join3(installPath, "commands"), source, pluginScope);
+      results.push(...pluginCommands);
+      const pluginSkills = await readSkillsFromDir(installPath, source, pluginScope);
+      results.push(...pluginSkills);
+    }
+  }
+  return results;
+}
+var BUILT_IN_COMMANDS;
+var init_usecase15 = __esm(() => {
+  BUILT_IN_COMMANDS = [
+    { name: "help", description: "Get help with using Claude Code" },
+    { name: "model", description: "Switch AI model" },
+    { name: "clear", description: "Clear conversation history" },
+    { name: "compact", description: "Compact conversation context" },
+    { name: "fast", description: "Toggle fast mode" },
+    { name: "cost", description: "Show usage costs" },
+    { name: "resume", description: "Resume previous session" }
+  ];
+});
+
+// src/commands/list-commands/command.ts
+var exports_command17 = {};
+__export(exports_command17, {
+  default: () => command_default17
+});
+var command_default17;
+var init_command17 = __esm(() => {
+  init_dist();
+  init_usecase15();
+  init_output();
+  command_default17 = defineCommand({
+    meta: {
+      name: "list-commands",
+      description: "List all available Claude Code slash commands and skills as JSON"
+    },
+    args: {
+      "project-path": {
+        type: "string",
+        description: "Path to the project root (defaults to cwd)"
+      }
+    },
+    async run({ args }) {
+      try {
+        const commands = await listCommands({
+          projectPath: args["project-path"]
+        });
+        console.log(JSON.stringify(commands, null, 2));
+      } catch (error48) {
+        err(error48 instanceof Error ? error48.message : String(error48));
+        process.exit(1);
+      }
+    }
+  });
+});
+
+// src/commands/send-commands/schema.ts
+var SendCommandsInput;
+var init_schema10 = __esm(() => {
+  init_zod();
+  SendCommandsInput = exports_external.object({
+    roomId: exports_external.string().min(1, "Room ID is required").regex(/^[a-zA-Z0-9_-]+$/, "Room ID must contain only alphanumeric characters, hyphens, and underscores"),
+    payload: exports_external.string().min(1, "JSON payload is required").refine((val) => {
+      try {
+        JSON.parse(val);
+        return true;
+      } catch {
+        return false;
+      }
+    }, { message: "Payload must be valid JSON" })
+  });
+});
+
+// src/commands/send-commands/usecase.ts
+async function sendCommands(client, input) {
+  const parsed = SendCommandsInput.parse(input);
+  await client.sendCommands(parsed.roomId, parsed.payload);
+  ok("Commands sent");
+}
+var init_usecase16 = __esm(() => {
+  init_schema10();
+  init_output();
+});
+
+// src/commands/send-commands/command.ts
+var exports_command18 = {};
+__export(exports_command18, {
+  default: () => command_default18
+});
+var command_default18;
+var init_command18 = __esm(() => {
+  init_dist();
+  init_client_factory();
+  init_usecase16();
+  init_output();
+  command_default18 = defineCommand({
+    meta: {
+      name: "send-commands",
+      description: "Send commands list to a room"
+    },
+    args: {
+      roomId: {
+        type: "positional",
+        description: "Room ID to send commands to",
+        required: true
+      },
+      payload: {
+        type: "positional",
+        description: "JSON commands payload",
+        required: false
+      }
+    },
+    async run({ args }) {
+      try {
+        const client = getClient();
+        let payload = args.payload;
+        if (!payload) {
+          const chunks = [];
+          for await (const chunk of process.stdin) {
+            chunks.push(chunk);
+          }
+          payload = Buffer.concat(chunks).toString("utf8").trim();
+        }
+        await sendCommands(client, { roomId: args.roomId, payload });
+      } catch (error48) {
+        err(error48 instanceof Error ? error48.message : String(error48));
+        process.exit(1);
+      }
+    }
+  });
+});
+
 // ../../node_modules/.bun/react@19.2.4/node_modules/react/cjs/react.development.js
 var require_react_development = __commonJS((exports, module) => {
   (function() {
@@ -17370,14 +17666,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       prevActScopeDepth !== actScopeDepth - 1 && console.error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
       actScopeDepth = prevActScopeDepth;
     }
-    function recursivelyFlushAsyncActWork(returnValue, resolve3, reject) {
+    function recursivelyFlushAsyncActWork(returnValue, resolve4, reject) {
       var queue = ReactSharedInternals.actQueue;
       if (queue !== null)
         if (queue.length !== 0)
           try {
             flushActQueue(queue);
             enqueueTask(function() {
-              return recursivelyFlushAsyncActWork(returnValue, resolve3, reject);
+              return recursivelyFlushAsyncActWork(returnValue, resolve4, reject);
             });
             return;
           } catch (error48) {
@@ -17385,7 +17681,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           }
         else
           ReactSharedInternals.actQueue = null;
-      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve3(returnValue);
+      0 < ReactSharedInternals.thrownErrors.length ? (queue = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(queue)) : resolve4(returnValue);
     }
     function flushActQueue(queue) {
       if (!isFlushing) {
@@ -17561,14 +17857,14 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
           didAwaitActCall || didWarnNoAwaitAct || (didWarnNoAwaitAct = true, console.error("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
         });
         return {
-          then: function(resolve3, reject) {
+          then: function(resolve4, reject) {
             didAwaitActCall = true;
             thenable.then(function(returnValue) {
               popActScope(prevActQueue, prevActScopeDepth);
               if (prevActScopeDepth === 0) {
                 try {
                   flushActQueue(queue), enqueueTask(function() {
-                    return recursivelyFlushAsyncActWork(returnValue, resolve3, reject);
+                    return recursivelyFlushAsyncActWork(returnValue, resolve4, reject);
                   });
                 } catch (error$0) {
                   ReactSharedInternals.thrownErrors.push(error$0);
@@ -17579,7 +17875,7 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
                   reject(_thrownError);
                 }
               } else
-                resolve3(returnValue);
+                resolve4(returnValue);
             }, function(error48) {
               popActScope(prevActQueue, prevActScopeDepth);
               0 < ReactSharedInternals.thrownErrors.length ? (error48 = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, reject(error48)) : reject(error48);
@@ -17595,11 +17891,11 @@ See https://react.dev/link/invalid-hook-call for tips about how to debug and fix
       if (0 < ReactSharedInternals.thrownErrors.length)
         throw callback = aggregateErrors(ReactSharedInternals.thrownErrors), ReactSharedInternals.thrownErrors.length = 0, callback;
       return {
-        then: function(resolve3, reject) {
+        then: function(resolve4, reject) {
           didAwaitActCall = true;
           prevActScopeDepth === 0 ? (ReactSharedInternals.actQueue = queue, enqueueTask(function() {
-            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve3, reject);
-          })) : resolve3(returnValue$jscomp$0);
+            return recursivelyFlushAsyncActWork(returnValue$jscomp$0, resolve4, reject);
+          })) : resolve4(returnValue$jscomp$0);
         }
       };
     };
@@ -23096,8 +23392,8 @@ It can also happen if the client has a browser extension installed which messes
         currentEntangledActionThenable = {
           status: "pending",
           value: undefined,
-          then: function(resolve3) {
-            entangledListeners.push(resolve3);
+          then: function(resolve4) {
+            entangledListeners.push(resolve4);
           }
         };
       }
@@ -23121,8 +23417,8 @@ It can also happen if the client has a browser extension installed which messes
         status: "pending",
         value: null,
         reason: null,
-        then: function(resolve3) {
-          listeners.push(resolve3);
+        then: function(resolve4) {
+          listeners.push(resolve4);
         }
       };
       thenable.then(function() {
@@ -53529,8 +53825,8 @@ class Ink {
     }
   }
   async waitUntilExit() {
-    this.exitPromise ||= new Promise((resolve3, reject) => {
-      this.resolveExitPromise = resolve3;
+    this.exitPromise ||= new Promise((resolve4, reject) => {
+      this.resolveExitPromise = resolve4;
       this.rejectExitPromise = reject;
     });
     if (!this.beforeExitHandler) {
@@ -54504,10 +54800,10 @@ class TmuxClient {
       "-S",
       `-${lines}`
     ];
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       execFileCb("tmux", args, { encoding: "utf8", timeout: 5000 }, (error48, stdout) => {
         if (error48) {
-          resolve3([]);
+          resolve4([]);
           return;
         }
         const result = stdout.split(`
@@ -54515,7 +54811,7 @@ class TmuxClient {
         while (result.length > 0 && result[result.length - 1] === "") {
           result.pop();
         }
-        resolve3(result);
+        resolve4(result);
       });
     });
   }
@@ -54552,8 +54848,8 @@ var init_tmux_client = __esm(() => {
 
 // src/lib/process-manager.ts
 import { mkdirSync as mkdirSync2, readFileSync as readFileSync6, writeFileSync as writeFileSync3, renameSync, lstatSync } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join3 } from "node:path";
+import { homedir as homedir4 } from "node:os";
+import { join as join4 } from "node:path";
 function readRegistry() {
   try {
     const data = readFileSync6(REGISTRY_PATH, "utf8");
@@ -54572,7 +54868,7 @@ function writeRegistry(entries) {
   } catch {
     return;
   }
-  const tmpPath = join3(REGISTRY_DIR, `sessions.${process.pid}.${Date.now()}.tmp`);
+  const tmpPath = join4(REGISTRY_DIR, `sessions.${process.pid}.${Date.now()}.tmp`);
   writeFileSync3(tmpPath, JSON.stringify(entries, null, 2), { mode: 384 });
   renameSync(tmpPath, REGISTRY_PATH);
 }
@@ -54775,8 +55071,8 @@ var init_process_manager = __esm(() => {
     roomName: exports_external.string(),
     createdAt: exports_external.string()
   });
-  REGISTRY_DIR = join3(homedir3(), ".meet-ai");
-  REGISTRY_PATH = join3(REGISTRY_DIR, "sessions.json");
+  REGISTRY_DIR = join4(homedir4(), ".meet-ai");
+  REGISTRY_PATH = join4(REGISTRY_DIR, "sessions.json");
   ENV_ALLOWLIST = [
     "HOME",
     "USER",
@@ -54792,32 +55088,32 @@ var init_process_manager = __esm(() => {
 
 // src/spawner.ts
 import { execSync } from "node:child_process";
-import { existsSync as existsSync4 } from "node:fs";
-import { homedir as homedir4, platform as platform2 } from "node:os";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync5 } from "node:fs";
+import { homedir as homedir5, platform as platform2 } from "node:os";
+import { join as join5 } from "node:path";
 function findClaudeCli() {
   try {
     const command = platform2() === "win32" ? "where claude" : "which claude";
     const result = execSync(command, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
     const claudePath = result.split(`
 `)[0].trim();
-    if (claudePath && existsSync4(claudePath)) {
+    if (claudePath && existsSync5(claudePath)) {
       return claudePath;
     }
   } catch {}
   const envPath = process.env.MEET_AI_CLAUDE_PATH;
-  if (envPath && existsSync4(envPath)) {
+  if (envPath && existsSync5(envPath)) {
     return envPath;
   }
-  const home = homedir4();
+  const home = homedir5();
   const commonPaths = [
-    join4(home, ".bun", "bin", "claude"),
+    join5(home, ".bun", "bin", "claude"),
     "/opt/homebrew/bin/claude",
     "/usr/local/bin/claude",
-    join4(home, ".local", "bin", "claude")
+    join5(home, ".local", "bin", "claude")
   ];
   for (const path of commonPaths) {
-    if (existsSync4(path)) {
+    if (existsSync5(path)) {
       return path;
     }
   }
@@ -56023,7 +56319,7 @@ async function startDashboard(client, config2, options) {
   cleanup();
 }
 var import_react31;
-var init_usecase15 = __esm(async () => {
+var init_usecase17 = __esm(async () => {
   init_process_manager();
   init_tmux_client();
   init_spawner();
@@ -56040,7 +56336,7 @@ init_output();
 var main = defineCommand({
   meta: {
     name: "meet-ai",
-    version: "0.0.20",
+    version: "0.0.22",
     description: "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket"
   },
   args: {
@@ -56062,7 +56358,9 @@ var main = defineCommand({
     "download-attachment": () => Promise.resolve().then(() => (init_command9(), exports_command9)).then((m) => m.default),
     "generate-key": () => Promise.resolve().then(() => (init_command10(), exports_command10)).then((m) => m.default),
     hook: () => Promise.resolve().then(() => (init_command15(), exports_command15)).then((m) => m.default),
-    "setup-hooks": () => Promise.resolve().then(() => (init_command16(), exports_command16)).then((m) => m.default)
+    "setup-hooks": () => Promise.resolve().then(() => (init_command16(), exports_command16)).then((m) => m.default),
+    "list-commands": () => Promise.resolve().then(() => (init_command17(), exports_command17)).then((m) => m.default),
+    "send-commands": () => Promise.resolve().then(() => (init_command18(), exports_command18)).then((m) => m.default)
   },
   async run({ args }) {
     const hasSubcommand = process.argv.length > 2;
@@ -56071,7 +56369,7 @@ var main = defineCommand({
     try {
       const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client_factory(), exports_client_factory));
       const { getMeetAiConfig: getMeetAiConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
-      const { startDashboard: startDashboard2 } = await init_usecase15().then(() => exports_usecase2);
+      const { startDashboard: startDashboard2 } = await init_usecase17().then(() => exports_usecase2);
       const client = getClient2();
       const config2 = getMeetAiConfig2();
       await startDashboard2(client, config2, { debug: args.debug });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meet-ai/cli",
-  "version": "0.0.20",
+  "version": "0.0.22",
   "description": "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket",
   "keywords": [
     "chat",