@meet-ai/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,403 @@
+#!/usr/bin/env node
+
+// src/client.ts
+function wsLog(data) {
+  const json = JSON.stringify({ ...data, ts: new Date().toISOString() });
+  const isSuccess = data.event === "connected" || data.event === "reconnected" || data.event === "catchup";
+  console.error(isSuccess ? `\x1B[32m${json}\x1B[0m` : json);
+}
+function isRetryable(error) {
+  if (error instanceof TypeError)
+    return true;
+  if (error instanceof Error && /^HTTP 5\d{2}$/.test(error.message))
+    return true;
+  return false;
+}
+async function withRetry(fn, options) {
+  const maxRetries = options?.maxRetries ?? 3;
+  const baseDelay = options?.baseDelay ?? 1000;
+  const shouldRetry = options?.shouldRetry ?? isRetryable;
+  let lastError;
+  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt >= maxRetries || !shouldRetry(err))
+        throw err;
+      const delay = baseDelay * 2 ** attempt;
+      console.error(JSON.stringify({
+        event: "retry",
+        attempt: attempt + 1,
+        delay_ms: delay,
+        error: err instanceof Error ? err.message : String(err)
+      }));
+      await new Promise((r) => setTimeout(r, delay));
+    }
+  }
+  throw lastError;
+}
+function createClient(baseUrl, apiKey) {
+  function headers(extra) {
+    const h = { "Content-Type": "application/json", ...extra };
+    if (apiKey) {
+      h["Authorization"] = `Bearer ${apiKey}`;
+    }
+    return h;
+  }
+  return {
+    async createRoom(name) {
+      const res = await fetch(`${baseUrl}/api/rooms`, {
+        method: "POST",
+        headers: headers(),
+        body: JSON.stringify({ name })
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error ?? `HTTP ${res.status}`);
+      }
+      return res.json();
+    },
+    async sendMessage(roomId, sender, content, color) {
+      return withRetry(async () => {
+        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/messages`, {
+          method: "POST",
+          headers: headers(),
+          body: JSON.stringify({ sender, content, sender_type: "agent", ...color && { color } })
+        });
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({}));
+          throw new Error(err.error ?? `HTTP ${res.status}`);
+        }
+        return res.json();
+      });
+    },
+    async getMessages(roomId, options) {
+      const params = new URLSearchParams;
+      if (options?.after)
+        params.set("after", options.after);
+      if (options?.exclude)
+        params.set("exclude", options.exclude);
+      if (options?.senderType)
+        params.set("sender_type", options.senderType);
+      const qs = params.toString();
+      const url = `${baseUrl}/api/rooms/${roomId}/messages${qs ? `?${qs}` : ""}`;
+      const res = await fetch(url, {
+        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error ?? `HTTP ${res.status}`);
+      }
+      return res.json();
+    },
+    listen(roomId, options) {
+      const wsUrl = baseUrl.replace(/^http/, "ws");
+      const tokenParam = apiKey ? `?token=${apiKey}` : "";
+      let pingInterval = null;
+      let reconnectAttempt = 0;
+      const seen = new Set;
+      let lastSeenId = null;
+      function deliver(msg) {
+        if (seen.has(msg.id))
+          return;
+        seen.add(msg.id);
+        if (seen.size > 200) {
+          const first = seen.values().next().value;
+          seen.delete(first);
+        }
+        lastSeenId = msg.id;
+        if (options?.exclude && msg.sender === options.exclude)
+          return;
+        if (options?.senderType && msg.sender_type !== options.senderType)
+          return;
+        if (options?.onMessage) {
+          options.onMessage(msg);
+        } else {
+          console.log(JSON.stringify(msg));
+        }
+      }
+      function getReconnectDelay() {
+        const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
+        reconnectAttempt++;
+        return delay + delay * 0.5 * Math.random();
+      }
+      const fetchMessages = this.getMessages.bind(this);
+      function connect() {
+        const ws = new WebSocket(`${wsUrl}/api/rooms/${roomId}/ws${tokenParam}`);
+        const connectTimeout = setTimeout(() => {
+          if (ws.readyState !== WebSocket.OPEN) {
+            wsLog({ event: "timeout", after_ms: 1e4 });
+            ws.close();
+          }
+        }, 1e4);
+        ws.onopen = async () => {
+          clearTimeout(connectTimeout);
+          const wasReconnect = reconnectAttempt > 0;
+          reconnectAttempt = 0;
+          wsLog({ event: wasReconnect ? "reconnected" : "connected" });
+          if (pingInterval)
+            clearInterval(pingInterval);
+          pingInterval = setInterval(() => {
+            if (ws.readyState === WebSocket.OPEN) {
+              ws.send(JSON.stringify({ type: "ping" }));
+            }
+          }, 30000);
+          if (lastSeenId) {
+            try {
+              const missed = await fetchMessages(roomId, { after: lastSeenId });
+              if (missed.length)
+                wsLog({ event: "catchup", count: missed.length });
+              for (const msg of missed)
+                deliver(msg);
+            } catch {}
+          }
+        };
+        ws.onmessage = (event) => {
+          const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+          const data = JSON.parse(text);
+          if (data.type === "pong")
+            return;
+          deliver(data);
+        };
+        ws.onclose = (event) => {
+          clearTimeout(connectTimeout);
+          if (pingInterval)
+            clearInterval(pingInterval);
+          const code = event.code;
+          if (code === 1000) {
+            wsLog({ event: "closed", code: 1000 });
+            return;
+          }
+          const reason = code === 1006 ? "network drop" : code === 1012 ? "service restart" : code === 1013 ? "server back-off" : `code ${code}`;
+          const delay = getReconnectDelay();
+          wsLog({ event: "disconnected", code, reason });
+          wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
+          setTimeout(connect, delay);
+        };
+        ws.onerror = () => {};
+        return ws;
+      }
+      return connect();
+    },
+    async generateKey() {
+      const res = await fetch(`${baseUrl}/api/keys`, {
+        method: "POST",
+        headers: headers()
+      });
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error ?? `HTTP ${res.status}`);
+      }
+      return res.json();
+    }
+  };
+}
+
+// src/inbox-router.ts
+import { readFileSync, writeFileSync, mkdirSync, statSync } from "fs";
+import { dirname } from "path";
+var IDLE_CHECK_INTERVAL_MS = 60000;
+var IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+function appendToInbox(path, entry) {
+  mkdirSync(dirname(path), { recursive: true });
+  let messages = [];
+  try {
+    messages = JSON.parse(readFileSync(path, "utf-8"));
+  } catch {}
+  messages.push(entry);
+  writeFileSync(path, JSON.stringify(messages, null, 2));
+}
+function getTeamMembers(teamDir) {
+  try {
+    const config = JSON.parse(readFileSync(`${teamDir}/config.json`, "utf-8"));
+    return new Set(config.members?.map((m) => m.name) || []);
+  } catch {
+    return new Set;
+  }
+}
+function resolveInboxTargets(content, members) {
+  const mentions = content.match(/@([\w-]+)/g);
+  if (!mentions)
+    return null;
+  const valid = [...new Set(mentions.map((m) => m.slice(1)))].filter((name) => members.has(name));
+  return valid.length > 0 ? valid : null;
+}
+function checkIdleAgents(inboxDir, members, excludeAgent, notified, now = Date.now()) {
+  const newlyIdle = [];
+  for (const member of members) {
+    if (member === excludeAgent)
+      continue;
+    const inboxPath = `${inboxDir}/${member}.json`;
+    let mtime;
+    try {
+      mtime = statSync(inboxPath).mtimeMs;
+    } catch {
+      continue;
+    }
+    const idleMs = now - mtime;
+    if (idleMs >= IDLE_THRESHOLD_MS) {
+      if (!notified.has(member)) {
+        newlyIdle.push(member);
+      }
+    } else {
+      notified.delete(member);
+    }
+  }
+  return newlyIdle;
+}
+
+// src/index.ts
+var API_URL = process.env.MEET_AI_URL || "http://localhost:8787";
+var API_KEY = process.env.MEET_AI_KEY;
+var client = createClient(API_URL, API_KEY);
+var [command, ...args] = process.argv.slice(2);
+function parseFlags(args2) {
+  const positional = [];
+  const flags = {};
+  for (let i = 0;i < args2.length; i++) {
+    if (args2[i].startsWith("--") && i + 1 < args2.length) {
+      flags[args2[i].slice(2)] = args2[i + 1];
+      i++;
+    } else {
+      positional.push(args2[i]);
+    }
+  }
+  return { positional, flags };
+}
+switch (command) {
+  case "create-room": {
+    const name = args[0];
+    if (!name) {
+      console.error("Usage: cli create-room <name>");
+      process.exit(1);
+    }
+    const room = await client.createRoom(name);
+    console.log(`Room created: ${room.id} (${room.name})`);
+    break;
+  }
+  case "send-message": {
+    const { positional: smPos, flags: smFlags } = parseFlags(args);
+    const [roomId, sender, ...rest] = smPos;
+    const content = rest.join(" ");
+    if (!roomId || !sender || !content) {
+      console.error("Usage: cli send-message <roomId> <sender> <content> [--color <color>]");
+      process.exit(1);
+    }
+    const msg = await client.sendMessage(roomId, sender, content, smFlags.color);
+    console.log(`Message sent: ${msg.id}`);
+    break;
+  }
+  case "poll": {
+    const { positional, flags } = parseFlags(args);
+    const roomId = positional[0];
+    if (!roomId) {
+      console.error("Usage: cli poll <roomId> [--after <messageId>] [--exclude <sender>]");
+      process.exit(1);
+    }
+    const messages = await client.getMessages(roomId, {
+      after: flags.after,
+      exclude: flags.exclude,
+      senderType: flags["sender-type"]
+    });
+    console.log(JSON.stringify(messages));
+    break;
+  }
+  case "listen": {
+    let routeToInbox = function(msg) {
+      if (!inboxDir)
+        return;
+      const entry = {
+        from: "meet-ai:" + msg.sender,
+        text: msg.content,
+        timestamp: new Date().toISOString(),
+        read: false
+      };
+      const members = teamDir ? getTeamMembers(teamDir) : new Set;
+      const targets = resolveInboxTargets(msg.content, members);
+      if (targets) {
+        for (const target of targets) {
+          appendToInbox(`${inboxDir}/${target}.json`, entry);
+        }
+      } else if (defaultInboxPath) {
+        appendToInbox(defaultInboxPath, entry);
+      }
+    }, shutdown = function() {
+      if (idleCheckTimeout)
+        clearTimeout(idleCheckTimeout);
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.close(1000, "client shutdown");
+      }
+      process.exit(0);
+    };
+    const { positional, flags } = parseFlags(args);
+    const roomId = positional[0];
+    if (!roomId) {
+      console.error("Usage: cli listen <roomId> [--exclude <sender>] [--sender-type <type>] [--team <name> --inbox <agent>]");
+      process.exit(1);
+    }
+    const team = flags.team;
+    const inbox = flags.inbox;
+    const inboxDir = team ? `${process.env.HOME}/.claude/teams/${team}/inboxes` : null;
+    const defaultInboxPath = inboxDir && inbox ? `${inboxDir}/${inbox}.json` : null;
+    const teamDir = team ? `${process.env.HOME}/.claude/teams/${team}` : null;
+    const onMessage = inboxDir ? (msg) => {
+      console.log(JSON.stringify(msg));
+      routeToInbox(msg);
+    } : undefined;
+    const ws = client.listen(roomId, { exclude: flags.exclude, senderType: flags["sender-type"], onMessage });
+    let idleCheckTimeout = null;
+    const idleNotified = new Set;
+    if (inboxDir && inbox && teamDir) {
+      let scheduleIdleCheck = function() {
+        idleCheckTimeout = setTimeout(() => {
+          const members = getTeamMembers(teamDir);
+          const newlyIdle = checkIdleAgents(inboxDir, members, inbox, idleNotified);
+          for (const agent of newlyIdle) {
+            idleNotified.add(agent);
+            if (defaultInboxPath) {
+              appendToInbox(defaultInboxPath, {
+                from: "meet-ai:idle-check",
+                text: `${agent} idle for 5+ minutes`,
+                timestamp: new Date().toISOString(),
+                read: false
+              });
+            }
+          }
+          scheduleIdleCheck();
+        }, IDLE_CHECK_INTERVAL_MS);
+      };
+      scheduleIdleCheck();
+    }
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    break;
+  }
+  case "generate-key": {
+    const result = await client.generateKey();
+    console.log(`API Key: ${result.key}`);
+    console.log(`Prefix:  ${result.prefix}`);
+    break;
+  }
+  default:
+    console.log(`meet-ai CLI
+
+Environment variables:
+  MEET_AI_URL   Server URL (default: http://localhost:8787)
+  MEET_AI_KEY   API key for authentication (optional for local, required for production)
+
+Commands:
+  create-room <name>                           Create a new chat room
+  send-message <roomId> <sender> <content>     Send a message to a room
+    --color <color>       Set sender name color (e.g. #ff0000, red)
+  poll <roomId> [options]                      Fetch messages from a room
+    --after <id>          Only messages after this ID
+    --exclude <sender>    Exclude messages from sender
+    --sender-type <type>  Filter by sender_type (human|agent)
+  listen <roomId> [options]                    Stream messages via WebSocket
+    --exclude <sender>    Exclude messages from sender
+    --sender-type <type>  Filter by sender_type (human|agent)
+    --team <name>         Write to Claude Code team inbox
+    --inbox <agent>       Target agent inbox (requires --team)
+  generate-key                                 Generate a new API key`);
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@meet-ai/cli",
+  "version": "0.0.1",
+  "description": "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket",
+  "type": "module",
+  "bin": {
+    "meet-ai": "./dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "bun run src/index.ts",
+    "build": "bun build src/index.ts --outdir dist --target node --format esm",
+    "prepublishOnly": "bun run build",
+    "test": "bun test"
+  },
+  "keywords": [
+    "meet-ai",
+    "cli",
+    "chat",
+    "websocket",
+    "real-time"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/SoftWare-A-G/meet-ai",
+    "directory": "packages/cli"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "5.9.3"
+  }
+}