@meet-ai/cli 0.0.33 → 0.0.35

package/dist/index.js

@@ -1590,10 +1590,10 @@ function fixedBase64(bodyLength, padding) {
 function fixedBase64url(length) {
   return new RegExp(`^[A-Za-z0-9_-]{${length}}$`);
 }
-var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uuid = (version) => {
-  if (!version)
+var cuid, cuid2, ulid, xid, ksuid, nanoid, duration, extendedDuration, guid, uuid = (version2) => {
+  if (!version2)
     return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
-  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
+  return new RegExp(`^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-${version2}[0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12})$`);
 }, uuid4, uuid6, uuid7, email, html5Email, rfc5322Email, unicodeEmail, idnEmail, browserEmail, _emoji = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`, ipv4, ipv6, mac = (delimiter) => {
   const escapedDelim = escapeRegex(delimiter ?? ":");
   return new RegExp(`^(?:[0-9A-F]{2}${escapedDelim}){5}[0-9A-F]{2}$|^(?:[0-9a-f]{2}${escapedDelim}){5}[0-9a-f]{2}$`);
@@ -2249,9 +2249,9 @@ class Doc {
 }
 
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/versions.js
-var version;
+var version2;
 var init_versions = __esm(() => {
-  version = {
+  version2 = {
     major: 4,
     minor: 3,
     patch: 6
@@ -2627,7 +2627,7 @@ var init_schemas = __esm(() => {
     inst ?? (inst = {});
     inst._zod.def = def;
     inst._zod.bag = inst._zod.bag || {};
-    inst._zod.version = version;
+    inst._zod.version = version2;
     const checks = [...inst._zod.def.checks ?? []];
     if (inst._zod.traits.has("$ZodCheck")) {
       checks.unshift(inst);
@@ -11912,7 +11912,7 @@ var init_json_schema = () => {};
 // ../../node_modules/.bun/zod@4.3.6/node_modules/zod/v4/core/index.js
 var exports_core2 = {};
 __export(exports_core2, {
-  version: () => version,
+  version: () => version2,
   util: () => exports_util,
   treeifyError: () => treeifyError,
   toJSONSchema: () => toJSONSchema,
@@ -14012,10 +14012,10 @@ function fromJSONSchema(schema, params) {
   if (typeof schema === "boolean") {
     return schema ? z.any() : z.never();
   }
-  const version2 = detectVersion(schema, params?.defaultTarget);
+  const version3 = detectVersion(schema, params?.defaultTarget);
   const defs = schema.$defs || schema.definitions || {};
   const ctx = {
-    version: version2,
+    version: version3,
     defs,
     refs: new Map,
     processing: new Set,
@@ -14456,12 +14456,7 @@ var init_config = __esm(() => {
   });
 });
 
-// src/client.ts
-function wsLog(data) {
-  const json2 = JSON.stringify({ ...data, ts: new Date().toISOString() });
-  const isSuccess = data.event === "connected" || data.event === "reconnected" || data.event === "catchup";
-  console.error(isSuccess ? `\x1B[32m${json2}\x1B[0m` : json2);
-}
+// src/domain/adapters/HttpTransport.ts
 function isRetryable(error48) {
   if (error48 instanceof TypeError)
     return true;
@@ -14493,391 +14488,751 @@ async function withRetry(fn, options) {
   }
   throw lastError;
 }
-function cleanupOldAttachments() {
+async function parseErrorMessage(res) {
   try {
-    const { readdirSync, statSync, unlinkSync } = __require("node:fs");
-    const now = Date.now();
-    for (const entry of readdirSync(ATTACHMENTS_DIR)) {
-      try {
-        const filePath = `${ATTACHMENTS_DIR}/${entry}`;
-        const mtime = statSync(filePath).mtimeMs;
-        if (now - mtime > MAX_AGE_MS) {
-          unlinkSync(filePath);
-        }
-      } catch {}
-    }
+    const err2 = await res.json();
+    const msg = err2.error;
+    if (typeof msg === "string")
+      return msg;
+    if (msg)
+      return JSON.stringify(msg);
   } catch {}
+  return `HTTP ${res.status}`;
 }
-function createClient(baseUrl, apiKey) {
-  function headers(extra) {
+
+class HttpTransport {
+  baseUrl;
+  apiKey;
+  constructor(baseUrl, apiKey) {
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  headers(extra) {
     const h = { "Content-Type": "application/json", ...extra };
-    if (apiKey) {
-      h["Authorization"] = `Bearer ${apiKey}`;
+    if (this.apiKey) {
+      h["Authorization"] = `Bearer ${this.apiKey}`;
     }
     return h;
   }
-  return {
-    async createRoom(name) {
-      const res = await fetch(`${baseUrl}/api/rooms`, {
+  authHeaders() {
+    return this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : undefined;
+  }
+  buildUrl(path, query) {
+    const params = new URLSearchParams;
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value)
+          params.set(key, value);
+      }
+    }
+    const qs = params.toString();
+    return `${this.baseUrl}${path}${qs ? `?${qs}` : ""}`;
+  }
+  async postJson(path, body, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
         method: "POST",
-        headers: headers(),
-        body: JSON.stringify({ name })
+        headers: this.headers(),
+        body: body !== undefined ? JSON.stringify(body) : undefined
       });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
       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 err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
-        }
-        return res.json();
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async postText(path, body, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
+        method: "POST",
+        headers: this.headers(),
+        body: body !== undefined ? JSON.stringify(body) : undefined
       });
-    },
-    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 url2 = `${baseUrl}/api/rooms/${roomId}/messages${qs ? `?${qs}` : ""}`;
-      const res = await fetch(url2, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
+      return res.text();
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async getJson(path, opts) {
+    const doRequest = async () => {
+      const res = await fetch(this.buildUrl(path, opts?.query), {
+        headers: this.authHeaders()
       });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
+      if (!res.ok)
+        throw new Error(await parseErrorMessage(res));
       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));
-        }
+    };
+    return opts?.retry ? withRetry(doRequest, opts.retry) : doRequest();
+  }
+  async getRaw(path) {
+    const res = await fetch(this.buildUrl(path), {
+      headers: this.authHeaders()
+    });
+    if (!res.ok)
+      throw new Error(await parseErrorMessage(res));
+    return res;
+  }
+  async del(path) {
+    const res = await fetch(this.buildUrl(path), {
+      method: "DELETE",
+      headers: this.headers()
+    });
+    if (!res.ok)
+      throw new Error(await parseErrorMessage(res));
+  }
+}
+
+// src/domain/adapters/ConnectionAdapter.ts
+function wsLog(data) {
+  const json2 = JSON.stringify({ ...data, ts: new Date().toISOString() });
+  const isSuccess = data.event === "connected" || data.event === "reconnected" || data.event === "catchup";
+  console.error(isSuccess ? `\x1B[32m${json2}\x1B[0m` : json2);
+}
+
+class ConnectionAdapter {
+  transport;
+  baseUrl;
+  apiKey;
+  constructor(transport, baseUrl, apiKey) {
+    this.transport = transport;
+    this.baseUrl = baseUrl;
+    this.apiKey = apiKey;
+  }
+  listen(roomId, options) {
+    const wsUrl = this.baseUrl.replace(/^http/, "ws");
+    const wsHeaders = this.apiKey ? { headers: { Authorization: `Bearer ${this.apiKey}` } } : undefined;
+    let pingInterval = null;
+    let reconnectAttempt = 0;
+    const seen = new Set;
+    let lastSeenId = null;
+    const transport = this.transport;
+    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);
       }
-      function getReconnectDelay() {
-        const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
-        reconnectAttempt++;
-        return delay + delay * 0.5 * Math.random();
+      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));
       }
-      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: 30000 });
-            try {
-              ws.close(4000, "connect timeout");
-            } catch {}
-            const delay = getReconnectDelay();
-            wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
-            setTimeout(connect, delay);
-          }
-        }, 30000);
-        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;
-          if (data.type === "terminal_subscribe" || data.type === "terminal_unsubscribe") {
-            options?.onMessage?.(data);
-            return;
-          }
-          if (data.type === "terminal_data")
-            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}`;
+    }
+    function getReconnectDelay() {
+      const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
+      reconnectAttempt++;
+      return delay + delay * 0.5 * Math.random();
+    }
+    function connect() {
+      const ws = new WebSocket(`${wsUrl}/api/rooms/${roomId}/ws`, wsHeaders);
+      const connectTimeout = setTimeout(() => {
+        if (ws.readyState !== WebSocket.OPEN) {
+          wsLog({ event: "timeout", after_ms: 30000 });
+          try {
+            ws.close(4000, "connect timeout");
+          } catch {}
           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 sendLog(roomId, sender, content, color, messageId) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/logs`, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({
-            sender,
-            content,
-            ...color && { color },
-            ...messageId && { message_id: messageId }
-          })
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
         }
-        return res.json();
-      });
-    },
-    async sendTeamInfo(roomId, payload) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/team-info`, {
-          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 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}`);
+      }, 30000);
+      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 transport.getJson(`/api/rooms/${roomId}/messages`, { query: { after: lastSeenId } });
+            if (missed.length)
+              wsLog({ event: "catchup", count: missed.length });
+            for (const msg of missed)
+              deliver(msg);
+          } catch {}
         }
-        return res.text();
-      });
-    },
-    async sendTasks(roomId, payload) {
-      return withRetry(async () => {
-        const res = await fetch(`${baseUrl}/api/rooms/${roomId}/tasks`, {
-          method: "POST",
-          headers: headers(),
-          body: payload
-        });
-        if (!res.ok) {
-          const err2 = await res.json().catch(() => ({}));
-          throw new Error(err2.error ?? `HTTP ${res.status}`);
+      };
+      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;
+        if (data.type === "terminal_subscribe" || data.type === "terminal_unsubscribe") {
+          options?.onMessage?.(data);
+          return;
         }
-        return res.text();
-      });
-    },
-    async getMessageAttachments(roomId, messageId) {
-      const res = await fetch(`${baseUrl}/api/rooms/${roomId}/messages/${messageId}/attachments`, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
-      return res.json();
-    },
-    async downloadAttachment(attachmentId) {
-      cleanupOldAttachments();
-      const res = await fetch(`${baseUrl}/api/attachments/${attachmentId}`, {
-        headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : undefined
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
-      }
-      const { mkdirSync, writeFileSync } = await import("node:fs");
-      const dir = "/tmp/meet-ai-attachments";
-      mkdirSync(dir, { recursive: true });
-      const safeId = attachmentId.replace(/[^a-zA-Z0-9_-]/g, "") || "unknown";
-      const localPath = `${dir}/${safeId}.bin`;
-      const buffer = Buffer.from(await res.arrayBuffer());
-      writeFileSync(localPath, buffer);
-      return localPath;
-    },
-    listenLobby(options) {
-      const wsUrl = baseUrl.replace(/^http/, "ws");
-      const tokenParam = apiKey ? `?token=${apiKey}` : "";
-      let pingInterval = null;
-      let reconnectAttempt = 0;
-      let reconnectScheduled = false;
-      const log = options?.silent ? () => {} : wsLog;
-      function getReconnectDelay() {
-        const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
-        reconnectAttempt++;
-        return delay + delay * 0.5 * Math.random();
-      }
-      function scheduleReconnect() {
-        if (reconnectScheduled)
+        if (data.type === "terminal_data")
+          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;
-        reconnectScheduled = true;
+        }
+        const reason = code === 1006 ? "network drop" : code === 1012 ? "service restart" : code === 1013 ? "server back-off" : `code ${code}`;
         const delay = getReconnectDelay();
-        log({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
-        setTimeout(() => {
-          reconnectScheduled = false;
-          connect();
-        }, delay);
-      }
-      function connect() {
-        const ws = new WebSocket(`${wsUrl}/api/lobby/ws${tokenParam}`);
-        const connectTimeout = setTimeout(() => {
-          if (ws.readyState !== WebSocket.OPEN) {
-            try {
-              ws.close(4000, "connect timeout");
-            } catch {}
-            scheduleReconnect();
-          }
-        }, 30000);
-        ws.onopen = () => {
-          clearTimeout(connectTimeout);
-          reconnectAttempt = 0;
-          log({ event: "lobby_connected" });
-          if (pingInterval)
-            clearInterval(pingInterval);
-          pingInterval = setInterval(() => {
-            if (ws.readyState === WebSocket.OPEN) {
-              ws.send(JSON.stringify({ type: "ping" }));
-            }
-          }, 30000);
-        };
-        ws.onmessage = (event) => {
-          const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        wsLog({ event: "disconnected", code, reason });
+        wsLog({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
+        setTimeout(connect, delay);
+      };
+      ws.onerror = () => {};
+      return ws;
+    }
+    return connect();
+  }
+  listenLobby(options) {
+    const wsUrl = this.baseUrl.replace(/^http/, "ws");
+    const wsHeaders = this.apiKey ? { headers: { Authorization: `Bearer ${this.apiKey}` } } : undefined;
+    let pingInterval = null;
+    let reconnectAttempt = 0;
+    let reconnectScheduled = false;
+    const log = options?.silent ? () => {} : wsLog;
+    function getReconnectDelay() {
+      const delay = Math.min(1000 * 2 ** Math.min(reconnectAttempt, 4), 15000);
+      reconnectAttempt++;
+      return delay + delay * 0.5 * Math.random();
+    }
+    function scheduleReconnect() {
+      if (reconnectScheduled)
+        return;
+      reconnectScheduled = true;
+      const delay = getReconnectDelay();
+      log({ event: "reconnecting", attempt: reconnectAttempt, delay_ms: Math.round(delay) });
+      setTimeout(() => {
+        reconnectScheduled = false;
+        connect();
+      }, delay);
+    }
+    function connect() {
+      const ws = new WebSocket(`${wsUrl}/api/lobby/ws`, wsHeaders);
+      const connectTimeout = setTimeout(() => {
+        if (ws.readyState !== WebSocket.OPEN) {
           try {
-            const data = JSON.parse(text);
-            if (data.type === "pong")
-              return;
-            if (data.type === "room_created" && data.id && data.name) {
-              options?.onRoomCreated?.(data.id, data.name);
-            }
-            if (data.type === "spawn_request" && data.room_name) {
-              options?.onSpawnRequest?.(data.room_name);
-            }
+            ws.close(4000, "connect timeout");
           } catch {}
-        };
-        ws.onclose = (event) => {
-          clearTimeout(connectTimeout);
-          if (pingInterval)
-            clearInterval(pingInterval);
-          if (event.code === 1000)
-            return;
           scheduleReconnect();
-        };
-        ws.onerror = () => {};
-        return ws;
+        }
+      }, 30000);
+      ws.onopen = () => {
+        clearTimeout(connectTimeout);
+        reconnectAttempt = 0;
+        log({ event: "lobby_connected" });
+        if (pingInterval)
+          clearInterval(pingInterval);
+        pingInterval = setInterval(() => {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "ping" }));
+          }
+        }, 30000);
+      };
+      ws.onmessage = (event) => {
+        const text = typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data);
+        try {
+          const data = JSON.parse(text);
+          if (data.type === "pong")
+            return;
+          if (data.type === "room_created" && data.id && data.name) {
+            options?.onRoomCreated?.(data.id, data.name);
+          }
+          if (data.type === "spawn_request" && data.room_name) {
+            options?.onSpawnRequest?.(data.room_name);
+          }
+        } catch {}
+      };
+      ws.onclose = (event) => {
+        clearTimeout(connectTimeout);
+        if (pingInterval)
+          clearInterval(pingInterval);
+        if (event.code === 1000)
+          return;
+        scheduleReconnect();
+      };
+      ws.onerror = () => {};
+      return ws;
+    }
+    return connect();
+  }
+  async generateKey() {
+    return this.transport.postJson("/api/keys");
+  }
+}
+
+// src/domain/adapters/FileSystemAdapter.ts
+import {
+  readFileSync as readFileSync2,
+  writeFileSync,
+  mkdirSync,
+  existsSync as existsSync2,
+  statSync
+} from "node:fs";
+
+class FileSystemAdapter {
+  readFileSync(path, encoding) {
+    return readFileSync2(path, encoding);
+  }
+  writeFileSync(path, data, encoding) {
+    writeFileSync(path, data, encoding);
+  }
+  mkdirSync(path, opts) {
+    mkdirSync(path, opts);
+  }
+  existsSync(path) {
+    return existsSync2(path);
+  }
+  statSync(path) {
+    const stat = statSync(path);
+    return { mtimeMs: stat.mtimeMs, size: stat.size };
+  }
+}
+var init_FileSystemAdapter = () => {};
+
+// src/domain/repositories/MessageRepository.ts
+class MessageRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async send(roomId, sender, content, color) {
+    return this.transport.postJson(`/api/rooms/${roomId}/messages`, { sender, content, sender_type: "agent", ...color && { color } }, RETRY);
+  }
+  async list(roomId, opts) {
+    const query = {};
+    if (opts?.after)
+      query.after = opts.after;
+    if (opts?.exclude)
+      query.exclude = opts.exclude;
+    if (opts?.senderType)
+      query.sender_type = opts.senderType;
+    return this.transport.getJson(`/api/rooms/${roomId}/messages`, { query });
+  }
+  async sendLog(roomId, sender, content, opts) {
+    return this.transport.postJson(`/api/rooms/${roomId}/logs`, {
+      sender,
+      content,
+      ...opts?.color && { color: opts.color },
+      ...opts?.messageId && { message_id: opts.messageId }
+    }, RETRY);
+  }
+}
+var RETRY;
+var init_MessageRepository = __esm(() => {
+  RETRY = { retry: { maxRetries: 3, baseDelay: 1000 } };
+});
+
+// src/domain/repositories/RoomRepository.ts
+class RoomRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async create(name) {
+    return this.transport.postJson("/api/rooms", { name });
+  }
+  async delete(roomId) {
+    return this.transport.del(`/api/rooms/${roomId}`);
+  }
+  async sendTeamInfo(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/team-info`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendCommands(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/commands`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendTasks(roomId, payload) {
+    return this.transport.postText(`/api/rooms/${roomId}/tasks`, JSON.parse(payload), {
+      retry: RETRY2
+    });
+  }
+  async sendTerminalData(roomId, data) {
+    try {
+      await this.transport.postJson(`/api/rooms/${roomId}/terminal`, { data });
+    } catch {}
+  }
+}
+var RETRY2;
+var init_RoomRepository = __esm(() => {
+  RETRY2 = { maxRetries: 3, baseDelay: 1000 };
+});
+
+// src/domain/repositories/AttachmentRepository.ts
+class AttachmentRepository {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async listForMessage(roomId, messageId) {
+    return this.transport.getJson(`/api/rooms/${roomId}/messages/${messageId}/attachments`);
+  }
+  async download(attachmentId) {
+    return this.transport.getRaw(`/api/attachments/${attachmentId}`);
+  }
+}
+
+// src/domain/usecases/SendMessage.ts
+class SendMessage {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, sender, content, color) {
+    return this.messageRepository.send(roomId, sender, content, color);
+  }
+}
+
+// src/domain/usecases/CreateRoom.ts
+class CreateRoom {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(name) {
+    return this.roomRepository.create(name);
+  }
+}
+
+// src/domain/usecases/DeleteRoom.ts
+class DeleteRoom {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId) {
+    return this.roomRepository.delete(roomId);
+  }
+}
+
+// src/domain/usecases/SendLog.ts
+class SendLog {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, sender, content, opts) {
+    return this.messageRepository.sendLog(roomId, sender, content, opts);
+  }
+}
+
+// src/domain/usecases/SendTeamInfo.ts
+class SendTeamInfo {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendTeamInfo(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendCommands.ts
+class SendCommands {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendCommands(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendTasks.ts
+class SendTasks {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, payload) {
+    return this.roomRepository.sendTasks(roomId, payload);
+  }
+}
+
+// src/domain/usecases/SendTerminalData.ts
+class SendTerminalData {
+  roomRepository;
+  constructor(roomRepository) {
+    this.roomRepository = roomRepository;
+  }
+  async execute(roomId, data) {
+    return this.roomRepository.sendTerminalData(roomId, data);
+  }
+}
+
+// src/domain/services/InboxRouter.ts
+import { dirname } from "node:path";
+
+class InboxRouter {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  route(msg, opts) {
+    const entry = {
+      from: `meet-ai:${msg.sender}`,
+      text: msg.content,
+      timestamp: new Date().toISOString(),
+      read: false
+    };
+    if (opts.attachmentPaths?.length) {
+      entry.attachments = opts.attachmentPaths;
+    }
+    const members = this.getTeamMembers(opts.teamDir);
+    const targets = this.resolveInboxTargets(msg.content, members);
+    if (targets) {
+      for (const target of targets) {
+        this.appendToInbox(`${opts.inboxDir}/${target}.json`, entry);
+      }
+    } else if (opts.stdinPane) {} else if (opts.defaultInboxPath) {
+      this.appendToInbox(opts.defaultInboxPath, entry);
+    }
+  }
+  checkIdle(opts) {
+    const members = this.getTeamMembers(opts.teamDir);
+    const newlyIdle = this.checkIdleAgents(opts.inboxDir, members, opts.inbox, opts.notified);
+    for (const agent of newlyIdle) {
+      opts.notified.add(agent);
+      if (opts.defaultInboxPath) {
+        this.appendToInbox(opts.defaultInboxPath, {
+          from: "meet-ai:idle-check",
+          text: `${agent} idle for 5+ minutes`,
+          timestamp: new Date().toISOString(),
+          read: false
+        });
       }
-      return connect();
-    },
-    async generateKey() {
-      const res = await fetch(`${baseUrl}/api/keys`, {
-        method: "POST",
-        headers: headers()
-      });
-      if (!res.ok) {
-        const err2 = await res.json();
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
+    }
+  }
+  appendToInbox(path, entry) {
+    this.fs.mkdirSync(dirname(path), { recursive: true });
+    let messages = [];
+    try {
+      messages = JSON.parse(this.fs.readFileSync(path, "utf-8"));
+    } catch {}
+    messages.push(entry);
+    this.fs.writeFileSync(path, JSON.stringify(messages, null, 2));
+  }
+  getTeamMembers(teamDir) {
+    try {
+      const config2 = JSON.parse(this.fs.readFileSync(`${teamDir}/config.json`, "utf-8"));
+      return new Set(config2.members?.map((m) => m.name) || []);
+    } catch {
+      return new Set;
+    }
+  }
+  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;
+  }
+  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 = this.fs.statSync(inboxPath).mtimeMs;
+      } catch {
+        continue;
       }
-      return res.json();
-    },
-    async deleteRoom(roomId) {
-      const res = await fetch(`${baseUrl}/api/rooms/${roomId}`, {
-        method: "DELETE",
-        headers: headers()
-      });
-      if (!res.ok) {
-        const err2 = await res.json().catch(() => ({}));
-        throw new Error(err2.error ?? `HTTP ${res.status}`);
+      const idleMs = now - mtime;
+      if (idleMs >= IDLE_THRESHOLD_MS) {
+        if (!notified.has(member)) {
+          newlyIdle.push(member);
+        }
+      } else {
+        notified.delete(member);
       }
-    },
-    async sendTerminalData(roomId, data) {
-      try {
-        await fetch(`${baseUrl}/api/rooms/${roomId}/terminal`, {
-          method: "POST",
-          headers: headers(),
-          body: JSON.stringify({ data })
-        });
-      } catch {}
     }
-  };
+    return newlyIdle;
+  }
 }
-var ATTACHMENTS_DIR = "/tmp/meet-ai-attachments", MAX_AGE_MS;
-var init_client = __esm(() => {
-  MAX_AGE_MS = 5 * 60 * 1000;
+var IDLE_THRESHOLD_MS;
+var init_InboxRouter = __esm(() => {
+  IDLE_THRESHOLD_MS = 5 * 60 * 1000;
 });
 
-// src/lib/client-factory.ts
-var exports_client_factory = {};
-__export(exports_client_factory, {
+// src/domain/usecases/Listen.ts
+class Listen {
+  connectionAdapter;
+  messageRepository;
+  constructor(connectionAdapter, messageRepository) {
+    this.connectionAdapter = connectionAdapter;
+    this.messageRepository = messageRepository;
+  }
+  execute(roomId, opts) {
+    return this.connectionAdapter.listen(roomId, opts);
+  }
+}
+
+// src/domain/usecases/ListenLobby.ts
+class ListenLobby {
+  connectionAdapter;
+  constructor(connectionAdapter) {
+    this.connectionAdapter = connectionAdapter;
+  }
+  execute(opts) {
+    return this.connectionAdapter.listenLobby(opts);
+  }
+}
+
+// src/domain/usecases/Poll.ts
+class Poll {
+  messageRepository;
+  constructor(messageRepository) {
+    this.messageRepository = messageRepository;
+  }
+  async execute(roomId, opts) {
+    return this.messageRepository.list(roomId, opts);
+  }
+}
+
+// src/domain/usecases/GenerateKey.ts
+class GenerateKey {
+  connectionAdapter;
+  constructor(connectionAdapter) {
+    this.connectionAdapter = connectionAdapter;
+  }
+  async execute() {
+    return this.connectionAdapter.generateKey();
+  }
+}
+
+// src/domain/usecases/GetAttachments.ts
+class GetAttachments {
+  attachmentRepository;
+  constructor(attachmentRepository) {
+    this.attachmentRepository = attachmentRepository;
+  }
+  async execute(roomId, messageId) {
+    return this.attachmentRepository.listForMessage(roomId, messageId);
+  }
+}
+
+// src/domain/usecases/DownloadAttachment.ts
+class DownloadAttachment {
+  attachmentRepository;
+  constructor(attachmentRepository) {
+    this.attachmentRepository = attachmentRepository;
+  }
+  async execute(attachmentId) {
+    return this.attachmentRepository.download(attachmentId);
+  }
+}
+
+// src/domain/bootstrap.ts
+var exports_bootstrap = {};
+__export(exports_bootstrap, {
+  getContainer: () => getContainer,
   getClient: () => getClient
 });
+function cleanupOldAttachments() {
+  try {
+    const { readdirSync, statSync: statSync2, unlinkSync } = __require("node:fs");
+    const now = Date.now();
+    for (const entry of readdirSync(ATTACHMENTS_DIR)) {
+      try {
+        const filePath = `${ATTACHMENTS_DIR}/${entry}`;
+        const mtime = statSync2(filePath).mtimeMs;
+        if (now - mtime > MAX_AGE_MS) {
+          unlinkSync(filePath);
+        }
+      } catch {}
+    }
+  } catch {}
+}
+function createContainer() {
+  const config2 = getMeetAiConfig();
+  const transport = new HttpTransport(config2.url, config2.key);
+  const messageRepository = new MessageRepository(transport);
+  const roomRepository = new RoomRepository(transport);
+  const attachmentRepository = new AttachmentRepository(transport);
+  const connectionAdapter = new ConnectionAdapter(transport, config2.url, config2.key);
+  const fileSystem = new FileSystemAdapter;
+  const inboxRouter = new InboxRouter(fileSystem);
+  return {
+    sendMessage: new SendMessage(messageRepository),
+    createRoom: new CreateRoom(roomRepository),
+    deleteRoom: new DeleteRoom(roomRepository),
+    sendLog: new SendLog(messageRepository),
+    sendTeamInfo: new SendTeamInfo(roomRepository),
+    sendCommands: new SendCommands(roomRepository),
+    sendTasks: new SendTasks(roomRepository),
+    sendTerminalData: new SendTerminalData(roomRepository),
+    listen: new Listen(connectionAdapter, messageRepository),
+    listenLobby: new ListenLobby(connectionAdapter),
+    poll: new Poll(messageRepository),
+    generateKey: new GenerateKey(connectionAdapter),
+    getAttachments: new GetAttachments(attachmentRepository),
+    downloadAttachment: new DownloadAttachment(attachmentRepository),
+    inboxRouter
+  };
+}
+function getContainer() {
+  if (!container) {
+    container = createContainer();
+  }
+  return container;
+}
 function getClient() {
-  if (!_client) {
-    const config2 = getMeetAiConfig();
-    _client = createClient(config2.url, config2.key);
-  }
-  return _client;
+  const c = getContainer();
+  return {
+    createRoom: (name) => c.createRoom.execute(name),
+    sendMessage: (roomId, sender, content, color) => c.sendMessage.execute(roomId, sender, content, color),
+    getMessages: (roomId, options) => c.poll.execute(roomId, options),
+    listen: (roomId, options) => c.listen.execute(roomId, options),
+    sendLog: (roomId, sender, content, color, messageId) => c.sendLog.execute(roomId, sender, content, { color, messageId }),
+    sendTeamInfo: (roomId, payload) => c.sendTeamInfo.execute(roomId, payload),
+    sendCommands: (roomId, payload) => c.sendCommands.execute(roomId, payload),
+    sendTasks: (roomId, payload) => c.sendTasks.execute(roomId, payload),
+    getMessageAttachments: (roomId, messageId) => c.getAttachments.execute(roomId, messageId),
+    downloadAttachment: async (attachmentId) => {
+      cleanupOldAttachments();
+      const response = await c.downloadAttachment.execute(attachmentId);
+      const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("node:fs");
+      mkdirSync2(ATTACHMENTS_DIR, { recursive: true });
+      const safeId = attachmentId.replace(/[^a-zA-Z0-9_-]/g, "") || "unknown";
+      const localPath = `${ATTACHMENTS_DIR}/${safeId}.bin`;
+      const buffer = Buffer.from(await response.arrayBuffer());
+      writeFileSync2(localPath, buffer);
+      return localPath;
+    },
+    listenLobby: (options) => c.listenLobby.execute(options),
+    generateKey: () => c.generateKey.execute(),
+    deleteRoom: (roomId) => c.deleteRoom.execute(roomId),
+    sendTerminalData: (roomId, data) => c.sendTerminalData.execute(roomId, data)
+  };
 }
-var _client = null;
-var init_client_factory = __esm(() => {
+var ATTACHMENTS_DIR = "/tmp/meet-ai-attachments", MAX_AGE_MS, container = null;
+var init_bootstrap = __esm(() => {
   init_config();
-  init_client();
+  init_FileSystemAdapter();
+  init_MessageRepository();
+  init_RoomRepository();
+  init_InboxRouter();
+  MAX_AGE_MS = 5 * 60 * 1000;
 });
 
 // src/commands/create-room/schema.ts
@@ -14909,7 +15264,7 @@ __export(exports_command, {
 var command_default;
 var init_command = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase();
   init_output();
   command_default = defineCommand({
@@ -14964,7 +15319,7 @@ __export(exports_command2, {
 var command_default2;
 var init_command2 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase2();
   init_output();
   command_default2 = defineCommand({
@@ -15040,7 +15395,7 @@ __export(exports_command3, {
 var command_default3;
 var init_command3 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase3();
   init_output();
   command_default3 = defineCommand({
@@ -15123,7 +15478,7 @@ __export(exports_command4, {
 var command_default4;
 var init_command4 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase4();
   init_output();
   command_default4 = defineCommand({
@@ -15241,7 +15596,7 @@ __export(exports_command5, {
 var command_default5;
 var init_command5 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase5();
   init_output();
   command_default5 = defineCommand({
@@ -15306,58 +15661,9 @@ var init_schema6 = __esm(() => {
 });
 
 // src/inbox-router.ts
-import { readFileSync as readFileSync2, writeFileSync, mkdirSync, statSync } from "node:fs";
-import { dirname } from "node:path";
-function appendToInbox(path, entry) {
-  mkdirSync(dirname(path), { recursive: true });
-  let messages = [];
-  try {
-    messages = JSON.parse(readFileSync2(path, "utf-8"));
-  } catch {}
-  messages.push(entry);
-  writeFileSync(path, JSON.stringify(messages, null, 2));
-}
-function getTeamMembers(teamDir) {
-  try {
-    const config2 = JSON.parse(readFileSync2(`${teamDir}/config.json`, "utf-8"));
-    return new Set(config2.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;
-}
-var IDLE_CHECK_INTERVAL_MS = 60000, IDLE_THRESHOLD_MS;
+var IDLE_CHECK_INTERVAL_MS = 60000, IDLE_THRESHOLD_MS2;
 var init_inbox_router = __esm(() => {
-  IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+  IDLE_THRESHOLD_MS2 = 5 * 60 * 1000;
 });
 
 // src/lib/tmux-client.ts
@@ -15367,10 +15673,10 @@ function validateSessionName(name) {
     throw new Error(`Invalid tmux session name: ${name}`);
   }
 }
-function parseVersion(version2) {
-  if (!version2)
+function parseVersion(version3) {
+  if (!version3)
     return [0, 0];
-  const match = version2.match(/(\d+)\.(\d+)/);
+  const match = version3.match(/(\d+)\.(\d+)/);
   if (!match)
     return [0, 0];
   return [Number(match[1]), Number(match[2])];
@@ -15580,27 +15886,7 @@ var init_tmux_client = __esm(() => {
 });
 
 // src/commands/listen/usecase.ts
-function routeToInbox(msg, inboxDir, defaultInboxPath, teamDir, stdinPane, attachmentPaths) {
-  const entry = {
-    from: `meet-ai:${msg.sender}`,
-    text: msg.content,
-    timestamp: new Date().toISOString(),
-    read: false
-  };
-  if (attachmentPaths?.length) {
-    entry.attachments = attachmentPaths;
-  }
-  const members = getTeamMembers(teamDir);
-  const targets = resolveInboxTargets(msg.content, members);
-  if (targets) {
-    for (const target of targets) {
-      appendToInbox(`${inboxDir}/${target}.json`, entry);
-    }
-  } else if (stdinPane) {} else if (defaultInboxPath) {
-    appendToInbox(defaultInboxPath, entry);
-  }
-}
-function listen(client, input) {
+function listen(client, input, inboxRouter) {
   const parsed = ListenInput.parse(input);
   const { roomId, exclude, senderType, team, inbox, stdinPane } = parsed;
   const inboxDir = team ? `${process.env.HOME}/.claude/teams/${team}/inboxes` : null;
@@ -15689,34 +15975,22 @@ function listen(client, input) {
       downloadMessageAttachments(client, msg.room_id, msg.id).then((paths) => {
         const output = paths.length ? { ...msg, attachments: paths } : msg;
         console.log(JSON.stringify(output));
-        if (inboxDir && teamDir)
-          routeToInbox(msg, inboxDir, defaultInboxPath, teamDir, stdinPane, paths);
+        if (inboxDir && teamDir && inboxRouter)
+          inboxRouter.route(msg, { inboxDir, defaultInboxPath, teamDir, stdinPane, attachmentPaths: paths });
       });
     } else {
       console.log(JSON.stringify(msg));
-      if (inboxDir && teamDir)
-        routeToInbox(msg, inboxDir, defaultInboxPath, teamDir, stdinPane);
+      if (inboxDir && teamDir && inboxRouter)
+        inboxRouter.route(msg, { inboxDir, defaultInboxPath, teamDir, stdinPane });
     }
   };
   const ws = client.listen(roomId, { exclude, senderType, onMessage });
   let idleCheckTimeout = null;
   const idleNotified = new Set;
-  if (inboxDir && inbox && teamDir) {
+  if (inboxDir && inbox && teamDir && inboxRouter) {
     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
-            });
-          }
-        }
+        inboxRouter.checkIdle({ inboxDir, teamDir, inbox, defaultInboxPath, notified: idleNotified });
         scheduleIdleCheck();
       }, IDLE_CHECK_INTERVAL_MS);
     };
@@ -15736,6 +16010,7 @@ function listen(client, input) {
   }
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
+  process.on("SIGHUP", shutdown);
   return ws;
 }
 var init_usecase6 = __esm(() => {
@@ -15752,7 +16027,7 @@ __export(exports_command6, {
 var command_default6;
 var init_command6 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase6();
   init_output();
   command_default6 = defineCommand({
@@ -15795,6 +16070,7 @@ var init_command6 = __esm(() => {
     run({ args }) {
       try {
         const client = getClient();
+        const container2 = getContainer();
         listen(client, {
           roomId: args.roomId,
           exclude: args.exclude,
@@ -15802,7 +16078,7 @@ var init_command6 = __esm(() => {
           team: args.team,
           inbox: args.inbox,
           stdinPane: args["stdin-pane"]
-        });
+        }, container2.inboxRouter);
       } catch (error48) {
         err(error48 instanceof Error ? error48.message : String(error48));
         process.exit(1);
@@ -15847,7 +16123,7 @@ __export(exports_command7, {
 var command_default7;
 var init_command7 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase7();
   init_output();
   command_default7 = defineCommand({
@@ -15915,7 +16191,7 @@ __export(exports_command8, {
 var command_default8;
 var init_command8 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase8();
   init_output();
   command_default8 = defineCommand({
@@ -15976,7 +16252,7 @@ __export(exports_command9, {
 var command_default9;
 var init_command9 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase9();
   init_output();
   command_default9 = defineCommand({
@@ -16019,7 +16295,7 @@ __export(exports_command10, {
 var command_default10;
 var init_command10 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_output();
   command_default10 = defineCommand({
     meta: {
@@ -16480,14 +16756,14 @@ var createProxy = (callback, path) => {
   }
   return req;
 }, []);
-var init_client2 = __esm(() => {
+var init_client = __esm(() => {
   init_cookie();
   init_utils();
 });
 
 // ../../node_modules/.bun/hono@4.11.8/node_modules/hono/dist/client/index.js
-var init_client3 = __esm(() => {
-  init_client2();
+var init_client2 = __esm(() => {
+  init_client();
   init_utils();
 });
 
@@ -16541,15 +16817,15 @@ async function sendLogEntry(client, roomId, summary, messageId) {
   } catch {}
 }
 var HOOK_COLOR = "#6b7280", HOOK_SENDER = "hook";
-var init_client4 = __esm(() => {
-  init_client3();
+var init_client3 = __esm(() => {
+  init_client2();
 });
 
 // src/lib/hooks/index.ts
 var init_hooks = __esm(() => {
   init_find_room();
   init_summarize();
-  init_client4();
+  init_client3();
 });
 
 // src/commands/hook/log-tool-use/usecase.ts
@@ -16851,7 +17127,7 @@ async function processPlanReview(rawInput, teamsDir) {
 }
 var POLL_INTERVAL_MS = 2000, POLL_TIMEOUT_MS = 2592000000;
 var init_usecase11 = __esm(() => {
-  init_client4();
+  init_client3();
   init_find_room();
 });
 
@@ -17047,7 +17323,7 @@ async function processQuestionReview(rawInput, teamsDir, opts) {
 }
 var POLL_INTERVAL_MS2 = 2000, POLL_TIMEOUT_MS2 = 1800000;
 var init_usecase12 = __esm(() => {
-  init_client4();
+  init_client3();
   init_find_room();
 });
 
@@ -17245,7 +17521,7 @@ async function processPermissionReview(rawInput, teamsDir, opts) {
 }
 var POLL_INTERVAL_MS3 = 2000, POLL_TIMEOUT_MS3 = 1800000;
 var init_usecase13 = __esm(() => {
-  init_client4();
+  init_client3();
   init_find_room();
 });
 
@@ -17302,7 +17578,7 @@ var init_command15 = __esm(() => {
 });
 
 // src/commands/setup-hooks/usecase.ts
-import { existsSync as existsSync2 } from "node:fs";
+import { existsSync as existsSync3 } from "node:fs";
 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";
@@ -17316,7 +17592,7 @@ function getSettingsPath(project) {
   return resolve2(homedir2(), ".claude", "settings.json");
 }
 async function readSettings(path) {
-  if (!existsSync2(path)) {
+  if (!existsSync3(path)) {
     return {};
   }
   const raw = await readFile(path, "utf-8");
@@ -17524,7 +17800,7 @@ var init_command16 = __esm(() => {
 });
 
 // src/commands/list-commands/usecase.ts
-import { existsSync as existsSync3 } from "node:fs";
+import { existsSync as existsSync4 } 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";
@@ -17544,7 +17820,7 @@ function parseYamlFrontmatter(content) {
 }
 async function readSkillsFromDir(baseDir, source, scope) {
   const skillsDir = join3(baseDir, "skills");
-  if (!existsSync3(skillsDir))
+  if (!existsSync4(skillsDir))
     return [];
   let entries;
   try {
@@ -17555,7 +17831,7 @@ async function readSkillsFromDir(baseDir, source, scope) {
   const results = [];
   for (const entry of entries) {
     const skillFile = join3(skillsDir, entry, "SKILL.md");
-    if (!existsSync3(skillFile))
+    if (!existsSync4(skillFile))
       continue;
     try {
       const content = await readFile2(skillFile, "utf-8");
@@ -17578,7 +17854,7 @@ async function readSkillsFromDir(baseDir, source, scope) {
   return results;
 }
 async function readCommandsFromDir(commandsDir, source, scope) {
-  if (!existsSync3(commandsDir))
+  if (!existsSync4(commandsDir))
     return [];
   const results = [];
   async function scanDir(dir) {
@@ -17616,7 +17892,7 @@ async function readCommandsFromDir(commandsDir, source, scope) {
   return results;
 }
 async function readSettings2(settingsPath) {
-  if (!existsSync3(settingsPath))
+  if (!existsSync4(settingsPath))
     return {};
   try {
     const raw = await readFile2(settingsPath, "utf-8");
@@ -17626,7 +17902,7 @@ async function readSettings2(settingsPath) {
   }
 }
 async function readInstalledPlugins(pluginsFile) {
-  if (!existsSync3(pluginsFile))
+  if (!existsSync4(pluginsFile))
     return {};
   try {
     const raw = await readFile2(pluginsFile, "utf-8");
@@ -17730,7 +18006,7 @@ __export(exports_command18, {
 var command_default18;
 var init_command18 = __esm(() => {
   init_dist();
-  init_client_factory();
+  init_bootstrap();
   init_usecase16();
   init_output();
   command_default18 = defineCommand({
@@ -27009,11 +27285,11 @@ https://react.dev/link/unsafe-component-lifecycles`, _instance, newApiName, stat
     function updateHostContainer(current2, workInProgress2) {
       if (supportsPersistence && doesRequireClone(current2, workInProgress2)) {
         current2 = workInProgress2.stateNode;
-        var container = current2.containerInfo, newChildSet = createContainerChildSet();
+        var container2 = current2.containerInfo, newChildSet = createContainerChildSet();
         appendAllChildrenToContainer(newChildSet, workInProgress2, false, false);
         current2.pendingChildren = newChildSet;
         markUpdate(workInProgress2);
-        finalizeContainerChildren(container, newChildSet);
+        finalizeContainerChildren(container2, newChildSet);
       }
     }
     function updateHostComponent(current2, workInProgress2, type, newProps) {
@@ -30275,27 +30551,27 @@ Check the render method of \`` + fiberTag + "`.");
       parentComponent = emptyContextObject;
       return parentComponent;
     }
-    function updateContainerSync(element, container, parentComponent, callback) {
-      updateContainerImpl(container.current, 2, element, container, parentComponent, callback);
+    function updateContainerSync(element, container2, parentComponent, callback) {
+      updateContainerImpl(container2.current, 2, element, container2, parentComponent, callback);
       return 2;
     }
-    function updateContainerImpl(rootFiber, lane, element, container, parentComponent, callback) {
+    function updateContainerImpl(rootFiber, lane, element, container2, parentComponent, callback) {
       if (injectedHook && typeof injectedHook.onScheduleFiberRoot === "function")
         try {
-          injectedHook.onScheduleFiberRoot(rendererID, container, element);
+          injectedHook.onScheduleFiberRoot(rendererID, container2, element);
         } catch (err2) {
           hasLoggedError || (hasLoggedError = true, console.error("React instrumentation encountered an error: %o", err2));
         }
       parentComponent = getContextForSubtree(parentComponent);
-      container.context === null ? container.context = parentComponent : container.pendingContext = parentComponent;
+      container2.context === null ? container2.context = parentComponent : container2.pendingContext = parentComponent;
       isRendering && current !== null && !didWarnAboutNestedUpdates && (didWarnAboutNestedUpdates = true, console.error(`Render methods should be a pure function of props and state; triggering nested component updates from render is not allowed. If necessary, trigger nested updates in componentDidUpdate.
 
 Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"));
-      container = createUpdate(lane);
-      container.payload = { element };
+      container2 = createUpdate(lane);
+      container2.payload = { element };
       callback = callback === undefined ? null : callback;
-      callback !== null && (typeof callback !== "function" && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container.callback = callback);
-      element = enqueueUpdate(rootFiber, container, lane);
+      callback !== null && (typeof callback !== "function" && console.error("Expected the last optional `callback` argument to be a function. Instead received: %s.", callback), container2.callback = callback);
+      element = enqueueUpdate(rootFiber, container2, lane);
       element !== null && (startUpdateTimerByLane(lane, "root.render()", null), scheduleUpdateOnFiber(element, rootFiber, lane), entangleTransitions(element, rootFiber, lane));
     }
     function markRetryLaneImpl(fiber, retryLane) {
@@ -32055,16 +32331,16 @@ No matching component was found for:
       }
       return null;
     };
-    exports2.getPublicRootInstance = function(container) {
-      container = container.current;
-      if (!container.child)
+    exports2.getPublicRootInstance = function(container2) {
+      container2 = container2.current;
+      if (!container2.child)
         return null;
-      switch (container.child.tag) {
+      switch (container2.child.tag) {
         case 27:
         case 5:
-          return getPublicInstance(container.child.stateNode);
+          return getPublicInstance(container2.child.stateNode);
         default:
-          return container.child.stateNode;
+          return container2.child.stateNode;
       }
     };
     exports2.injectIntoDevTools = function() {
@@ -32136,9 +32412,9 @@ No matching component was found for:
         return action(formData);
       });
     };
-    exports2.updateContainer = function(element, container, parentComponent, callback) {
-      var current2 = container.current, lane = requestUpdateLane(current2);
-      updateContainerImpl(current2, lane, element, container, parentComponent, callback);
+    exports2.updateContainer = function(element, container2, parentComponent, callback) {
+      var current2 = container2.current, lane = requestUpdateLane(current2);
+      updateContainerImpl(current2, lane, element, container2, parentComponent, callback);
       return lane;
     };
     exports2.updateContainerSync = updateContainerSync;
@@ -36561,7 +36837,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       socket.on("error", socketOnError);
       const key = req.headers["sec-websocket-key"];
       const upgrade = req.headers.upgrade;
-      const version2 = +req.headers["sec-websocket-version"];
+      const version3 = +req.headers["sec-websocket-version"];
       if (req.method !== "GET") {
         const message = "Invalid HTTP method";
         abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
@@ -36577,7 +36853,7 @@ var require_websocket_server = __commonJS((exports, module) => {
         abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
         return;
       }
-      if (version2 !== 13 && version2 !== 8) {
+      if (version3 !== 13 && version3 !== 8) {
         const message = "Missing or invalid Sec-WebSocket-Version header";
         abortHandshakeOrEmitwsClientError(this, req, socket, 400, message, {
           "Sec-WebSocket-Version": "13, 8"
@@ -36617,7 +36893,7 @@ var require_websocket_server = __commonJS((exports, module) => {
       }
       if (this.options.verifyClient) {
         const info2 = {
-          origin: req.headers[`${version2 === 8 ? "sec-websocket-origin" : "origin"}`],
+          origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
           secure: !!(req.socket.authorized || req.socket.encrypted),
           req
         };
@@ -39452,20 +39728,20 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
           return 0;
         };
-        var validate2 = function validate3(version2) {
-          return typeof version2 === "string" && /^[v\d]/.test(version2) && semver.test(version2);
+        var validate2 = function validate3(version3) {
+          return typeof version3 === "string" && /^[v\d]/.test(version3) && semver.test(version3);
         };
         var compare = function compare2(v1, v2, operator) {
           assertValidOperator(operator);
           var res = compareVersions(v1, v2);
           return operatorResMap[operator].includes(res);
         };
-        var satisfies = function satisfies2(version2, range) {
+        var satisfies = function satisfies2(version3, range) {
           var m = range.match(/^([<>=~^]+)/);
           var op = m ? m[1] : "=";
           if (op !== "^" && op !== "~")
-            return compare(version2, range, op);
-          var _validateAndParse = validateAndParse(version2), _validateAndParse2 = _slicedToArray(_validateAndParse, 5), v1 = _validateAndParse2[0], v2 = _validateAndParse2[1], v3 = _validateAndParse2[2], vp = _validateAndParse2[4];
+            return compare(version3, range, op);
+          var _validateAndParse = validateAndParse(version3), _validateAndParse2 = _slicedToArray(_validateAndParse, 5), v1 = _validateAndParse2[0], v2 = _validateAndParse2[1], v3 = _validateAndParse2[2], vp = _validateAndParse2[4];
           var _validateAndParse3 = validateAndParse(range), _validateAndParse4 = _slicedToArray(_validateAndParse3, 5), r1 = _validateAndParse4[0], r2 = _validateAndParse4[1], r3 = _validateAndParse4[2], rp = _validateAndParse4[4];
           var v = [v1, v2, v3];
           var r = [r1, r2 !== null && r2 !== undefined ? r2 : "x", r3 !== null && r3 !== undefined ? r3 : "x"];
@@ -39488,13 +39764,13 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return true;
         };
         var semver = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\-]+(?:\.[\da-z\-]+)*))?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?)?)?$/i;
-        var validateAndParse = function validateAndParse2(version2) {
-          if (typeof version2 !== "string") {
+        var validateAndParse = function validateAndParse2(version3) {
+          if (typeof version3 !== "string") {
             throw new TypeError("Invalid argument expected string");
           }
-          var match = version2.match(semver);
+          var match = version3.match(semver);
           if (!match) {
-            throw new Error("Invalid argument not valid semver ('".concat(version2, "' received)"));
+            throw new Error("Invalid argument not valid semver ('".concat(version3, "' received)"));
           }
           match.shift();
           return match;
@@ -41128,11 +41404,11 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           return obj;
         }
         var FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER = "999.9.9";
-        function hasAssignedBackend(version2) {
-          if (version2 == null || version2 === "") {
+        function hasAssignedBackend(version3) {
+          if (version3 == null || version3 === "") {
             return false;
           }
-          return gte(version2, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
+          return gte(version3, FIRST_DEVTOOLS_BACKEND_LOCKSTEP_VER);
         }
         function cleanForBridge(data, isPathAllowed) {
           var path = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
@@ -41611,7 +41887,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         }
         var Overlay_assign = Object.assign;
         var OverlayRect = /* @__PURE__ */ function() {
-          function OverlayRect2(doc2, container) {
+          function OverlayRect2(doc2, container2) {
             Overlay_classCallCheck(this, OverlayRect2);
             this.node = doc2.createElement("div");
             this.border = doc2.createElement("div");
@@ -41629,7 +41905,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             this.node.appendChild(this.border);
             this.border.appendChild(this.padding);
             this.padding.appendChild(this.content);
-            container.appendChild(this.node);
+            container2.appendChild(this.node);
           }
           return Overlay_createClass(OverlayRect2, [{
             key: "remove",
@@ -41656,7 +41932,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }]);
         }();
         var OverlayTip = /* @__PURE__ */ function() {
-          function OverlayTip2(doc2, container) {
+          function OverlayTip2(doc2, container2) {
             Overlay_classCallCheck(this, OverlayTip2);
             this.tip = doc2.createElement("div");
             Overlay_assign(this.tip.style, {
@@ -41686,7 +41962,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               color: "#d7d7d7"
             });
             this.tip.style.zIndex = "10000000";
-            container.appendChild(this.tip);
+            container2.appendChild(this.tip);
           }
           return Overlay_createClass(OverlayTip2, [{
             key: "remove",
@@ -42788,9 +43064,9 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               }
             });
             agent_defineProperty(_this2, "getBackendVersion", function() {
-              var version2 = "6.1.5-5d87cd2244";
-              if (version2) {
-                _this2._bridge.send("backendVersion", version2);
+              var version3 = "6.1.5-5d87cd2244";
+              if (version3) {
+                _this2._bridge.send("backendVersion", version3);
               }
             });
             agent_defineProperty(_this2, "getBridgeProtocol", function() {
@@ -45318,7 +45594,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
         } : function() {
           return Date.now();
         };
-        function getInternalReactConstants(version2) {
+        function getInternalReactConstants(version3) {
           var ReactPriorityLevels = {
             ImmediatePriority: 99,
             UserBlockingPriority: 98,
@@ -45327,7 +45603,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             IdlePriority: 95,
             NoPriority: 90
           };
-          if (gt(version2, "17.0.2")) {
+          if (gt(version3, "17.0.2")) {
             ReactPriorityLevels = {
               ImmediatePriority: 1,
               UserBlockingPriority: 2,
@@ -45338,15 +45614,15 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
             };
           }
           var StrictModeBits = 0;
-          if (gte(version2, "18.0.0-alpha")) {
+          if (gte(version3, "18.0.0-alpha")) {
             StrictModeBits = 24;
-          } else if (gte(version2, "16.9.0")) {
+          } else if (gte(version3, "16.9.0")) {
             StrictModeBits = 1;
-          } else if (gte(version2, "16.3.0")) {
+          } else if (gte(version3, "16.3.0")) {
             StrictModeBits = 2;
           }
           var ReactTypeOfWork = null;
-          if (gt(version2, "17.0.1")) {
+          if (gt(version3, "17.0.1")) {
             ReactTypeOfWork = {
               CacheComponent: 24,
               ClassComponent: 1,
@@ -45383,7 +45659,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: 30,
               ActivityComponent: 31
             };
-          } else if (gte(version2, "17.0.0-alpha")) {
+          } else if (gte(version3, "17.0.0-alpha")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 1,
@@ -45420,7 +45696,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: -1,
               ActivityComponent: -1
             };
-          } else if (gte(version2, "16.6.0-beta.0")) {
+          } else if (gte(version3, "16.6.0-beta.0")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 1,
@@ -45457,7 +45733,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               ViewTransitionComponent: -1,
               ActivityComponent: -1
             };
-          } else if (gte(version2, "16.4.3-alpha")) {
+          } else if (gte(version3, "16.4.3-alpha")) {
             ReactTypeOfWork = {
               CacheComponent: -1,
               ClassComponent: 2,
@@ -45743,8 +46019,8 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
           }
         }
         function renderer_attach(hook, rendererID, renderer, global2, shouldStartProfilingNow, profilingSettings) {
-          var version2 = renderer.reconcilerVersion || renderer.version;
-          var _getInternalReactCons = getInternalReactConstants(version2), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, StrictModeBits = _getInternalReactCons.StrictModeBits;
+          var version3 = renderer.reconcilerVersion || renderer.version;
+          var _getInternalReactCons = getInternalReactConstants(version3), getDisplayNameForFiber = _getInternalReactCons.getDisplayNameForFiber, getTypeSymbol = _getInternalReactCons.getTypeSymbol, ReactPriorityLevels = _getInternalReactCons.ReactPriorityLevels, ReactTypeOfWork = _getInternalReactCons.ReactTypeOfWork, StrictModeBits = _getInternalReactCons.StrictModeBits;
           var { ActivityComponent, CacheComponent, ClassComponent, ContextConsumer, DehydratedSuspenseComponent, ForwardRef, Fragment, FunctionComponent, HostRoot, HostHoistable, HostSingleton, HostPortal, HostComponent, HostText, IncompleteClassComponent, IncompleteFunctionComponent, IndeterminateComponent, LegacyHiddenComponent, MemoComponent, OffscreenComponent, SimpleMemoComponent, SuspenseComponent, SuspenseListComponent, TracingMarkerComponent, Throw, ViewTransitionComponent } = ReactTypeOfWork;
           var { ImmediatePriority, UserBlockingPriority, NormalPriority, LowPriority, IdlePriority, NoPriority } = ReactPriorityLevels;
           var { getLaneLabelMap, injectProfilingHooks, overrideHookState, overrideHookStateDeletePath, overrideHookStateRenamePath, overrideProps, overridePropsDeletePath, overridePropsRenamePath, scheduleRefresh, setErrorHandler, setSuspenseHandler, scheduleUpdate, getCurrentFiber } = renderer;
@@ -45770,7 +46046,7 @@ In order to be iterable, non-array objects must have a [Symbol.iterator]() metho
               getLaneLabelMap,
               currentDispatcherRef: getDispatcherRef(renderer),
               workTagMap: ReactTypeOfWork,
-              reactVersion: version2
+              reactVersion: version3
             });
             injectProfilingHooks(response.profilingHooks);
             getTimelineData = response.getTimelineData;
@@ -49649,8 +49925,8 @@ The error thrown in the component is:
             getEnvironmentNames
           };
         }
-        function isMatchingRender(version2) {
-          return !hasAssignedBackend(version2);
+        function isMatchingRender(version3) {
+          return !hasAssignedBackend(version3);
         }
         function attachRenderer(hook, id, renderer, global2, shouldStartProfilingNow, profilingSettings) {
           if (!isMatchingRender(renderer.reconcilerVersion || renderer.version)) {
@@ -51503,10 +51779,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env2) {
-    const version2 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version3 = Number.parseInt((env2.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env2.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
+        return version3 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -55360,7 +55636,7 @@ var init_process_manager = __esm(() => {
 
 // src/spawner.ts
 import { execSync } from "node:child_process";
-import { existsSync as existsSync5 } from "node:fs";
+import { existsSync as existsSync6 } from "node:fs";
 import { homedir as homedir5, platform as platform2 } from "node:os";
 import { join as join5 } from "node:path";
 function findClaudeCli() {
@@ -55369,12 +55645,12 @@ function findClaudeCli() {
     const result = execSync(command, { encoding: "utf8", stdio: ["pipe", "pipe", "ignore"] }).trim();
     const claudePath = result.split(`
 `)[0].trim();
-    if (claudePath && existsSync5(claudePath)) {
+    if (claudePath && existsSync6(claudePath)) {
       return claudePath;
     }
   } catch {}
   const envPath = process.env.MEET_AI_CLAUDE_PATH;
-  if (envPath && existsSync5(envPath)) {
+  if (envPath && existsSync6(envPath)) {
     return envPath;
   }
   const home = homedir5();
@@ -55385,7 +55661,7 @@ function findClaudeCli() {
     join5(home, ".local", "bin", "claude")
   ];
   for (const path of commonPaths) {
-    if (existsSync5(path)) {
+    if (existsSync6(path)) {
       return path;
     }
   }
@@ -56604,11 +56880,15 @@ var init_usecase17 = __esm(async () => {
 
 // src/index.ts
 init_dist();
+// package.json
+var version = "0.0.35";
+
+// src/index.ts
 init_output();
 var main = defineCommand({
   meta: {
     name: "meet-ai",
-    version: "0.0.33",
+    version,
     description: "CLI for meet-ai chat rooms — create rooms, send messages, and stream via WebSocket"
   },
   args: {
@@ -56639,7 +56919,7 @@ var main = defineCommand({
     if (hasSubcommand)
       return;
     try {
-      const { getClient: getClient2 } = await Promise.resolve().then(() => (init_client_factory(), exports_client_factory));
+      const { getClient: getClient2 } = await Promise.resolve().then(() => (init_bootstrap(), exports_bootstrap));
       const { getMeetAiConfig: getMeetAiConfig2 } = await Promise.resolve().then(() => (init_config(), exports_config));
       const { startDashboard: startDashboard2 } = await init_usecase17().then(() => exports_usecase2);
       const client = getClient2();