@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/dist/handlers-0aspcejm.js

@@ -0,0 +1,603 @@
+import {
+  bufferThreadMessage,
+  formatSlackSteeringAck,
+  getBufferMessageCount,
+  instantFlush,
+  requestSlackThreadSteering,
+  wasEventSeen
+} from "./cli-f146mn5s.js";
+import {
+  bufferedFileFailures,
+  buildEffectiveText,
+  createSlackTaskWithFiles,
+  extractSlackMessageText,
+  extractTaskFromMessage,
+  fetchSlackFiles,
+  hasOtherUserMention,
+  notifySlackFileFailures,
+  routeMessage
+} from "./cli-mmemxxdc.js";
+import"./cli-jsp14b6c.js";
+import {
+  enrichSlackUserEmail,
+  resolveSlackUserId,
+  rewriteSlackMentions
+} from "./cli-dttph1bw.js";
+import"./cli-p1d5b073.js";
+import"./cli-53s590z8.js";
+import {
+  ackSlackMessage,
+  buildTreeBlocks,
+  ensureSlackThreadTree,
+  isSlackRenderV2Enabled,
+  registerTreeMessage
+} from "./cli-b5bq9crk.js";
+import"./cli-q51yprfq.js";
+import"./cli-9d8ntetj.js";
+import"./cli-yatxqynm.js";
+import {
+  getAgentById,
+  getAgentWorkingOnThread,
+  getLeadAgent,
+  getMostRecentTaskInThread,
+  getTasksByAgentId,
+  init_context_key,
+  init_db,
+  reactionName,
+  slackContextKey
+} from "./cli-ftht3zzj.js";
+import"./cli-y6b6fb76.js";
+import {
+  init_resolver,
+  resolveTemplate
+} from "./cli-kpv03zhj.js";
+import"./cli-e29gmdmw.js";
+import"./cli-c2mk1kgf.js";
+import {
+  init_env_flag,
+  isEnvFlagEnabled
+} from "./cli-ej6gbxfb.js";
+import"./cli-sd0mxa3c.js";
+import"./cli-w5e1d1vv.js";
+import"./cli-w9kb3bk1.js";
+import"./cli-xqcq9y5e.js";
+import"./cli-pzxba7gw.js";
+import {
+  init_event_bus,
+  workflowEventBus
+} from "./cli-f7kvq46p.js";
+import"./cli-zf8jjwex.js";
+import"./cli-bd957dgb.js";
+import {
+  __callDispose,
+  __using
+} from "./cli-bc05qbss.js";
+
+// src/slack/handlers.ts
+init_db();
+init_resolver();
+init_context_key();
+init_event_bus();
+init_env_flag();
+var allowedEmailDomains = (process.env.SLACK_ALLOWED_EMAIL_DOMAINS || "").split(",").map((d) => d.trim().toLowerCase()).filter(Boolean);
+var allowedUserIds = (process.env.SLACK_ALLOWED_USER_IDS || "").split(",").map((id) => id.trim()).filter(Boolean);
+var filteringEnabled = allowedEmailDomains.length > 0 || allowedUserIds.length > 0;
+function checkUserAccess(userId, email, config) {
+  const { allowedEmailDomains: domains, allowedUserIds: userIds } = config;
+  if (domains.length === 0 && userIds.length === 0) {
+    return true;
+  }
+  if (userIds.includes(userId)) {
+    return true;
+  }
+  if (domains.length === 0) {
+    return false;
+  }
+  if (!email) {
+    return false;
+  }
+  const domain = email.split("@")[1]?.toLowerCase();
+  if (!domain) {
+    return false;
+  }
+  return domains.includes(domain);
+}
+async function isUserAllowed(client, userId) {
+  if (!filteringEnabled) {
+    return true;
+  }
+  if (allowedUserIds.includes(userId)) {
+    return true;
+  }
+  if (allowedEmailDomains.length === 0) {
+    return false;
+  }
+  const email = await enrichSlackUserEmail(client, userId);
+  if (!email) {
+    console.log(`[Slack] User ${userId} has no email, denying access`);
+    return false;
+  }
+  const domain = email.split("@")[1]?.toLowerCase();
+  if (!domain) {
+    console.log(`[Slack] User ${userId} has invalid email format, denying access`);
+    return false;
+  }
+  const allowed = allowedEmailDomains.includes(domain);
+  if (!allowed) {
+    console.log(`[Slack] User ${userId} email domain "${domain}" not in allowed list`);
+  }
+  return allowed;
+}
+function isBotMessage(event, botUserId) {
+  if (event.subtype === "bot_message")
+    return true;
+  if (event.bot_id)
+    return true;
+  if (botUserId && event.user === botUserId)
+    return true;
+  return false;
+}
+var cachedBotUserId = null;
+var cachedBotId = null;
+var swarmThreadRootCache = new Map;
+var SWARM_THREAD_ROOT_CACHE_MAX = 1000;
+function resetSlackHandlerCachesForTesting() {
+  cachedBotUserId = null;
+  cachedBotId = null;
+  swarmThreadRootCache.clear();
+}
+function isSwarmThreadRoot(root, botUserId, botId) {
+  if (!root)
+    return false;
+  if (botUserId && root.user === botUserId)
+    return true;
+  if (botId && root.bot_id === botId)
+    return true;
+  return false;
+}
+async function wasThreadStartedBySwarm(client, channelId, threadTs) {
+  const key = `${channelId}:${threadTs}`;
+  const cached = swarmThreadRootCache.get(key);
+  if (cached !== undefined)
+    return cached;
+  let startedBySwarm = false;
+  try {
+    const resp = await client.conversations.replies({
+      channel: channelId,
+      ts: threadTs,
+      limit: 1,
+      inclusive: true
+    });
+    const root = resp.messages?.[0];
+    startedBySwarm = isSwarmThreadRoot(root, cachedBotUserId, cachedBotId);
+  } catch (error) {
+    console.error("[Slack] Failed to check whether thread was started by swarm:", error);
+  }
+  if (swarmThreadRootCache.size >= SWARM_THREAD_ROOT_CACHE_MAX) {
+    const oldest = swarmThreadRootCache.keys().next().value;
+    if (oldest !== undefined)
+      swarmThreadRootCache.delete(oldest);
+  }
+  swarmThreadRootCache.set(key, startedBySwarm);
+  return startedBySwarm;
+}
+async function hasSwarmThreadActivity(client, channelId, threadTs) {
+  return await getAgentWorkingOnThread(channelId, threadTs) !== null || await wasThreadStartedBySwarm(client, channelId, threadTs);
+}
+async function getThreadContext(client, channel, threadTs, currentTs, botUserId) {
+  if (!threadTs)
+    return "";
+  try {
+    const result = await client.conversations.replies({
+      channel,
+      ts: threadTs,
+      limit: 20
+    });
+    const messages = result.messages || [];
+    const previousMessages = messages.filter((m) => {
+      if (m.ts === currentTs)
+        return false;
+      return extractSlackMessageText(m) !== "";
+    });
+    if (previousMessages.length === 0)
+      return "";
+    const formattedMessages = [];
+    for (const m of previousMessages) {
+      const isBotMessage2 = m.user === botUserId || m.bot_id !== undefined || m.subtype === "bot_message";
+      const text = extractSlackMessageText(m);
+      if (isBotMessage2) {
+        const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
+        formattedMessages.push(`[Agent]: ${truncatedText}`);
+      } else {
+        const authorTag = m.user ? `<@${m.user}>` : "Unknown";
+        formattedMessages.push(`${authorTag}: ${text}`);
+      }
+    }
+    return await rewriteSlackMentions(formattedMessages.join(`
+`), botUserId);
+  } catch (error) {
+    console.error("[Slack] Failed to fetch thread context:", error);
+    return "";
+  }
+}
+var processedMessages = new Set;
+var MESSAGE_DEDUP_TTL = 60000;
+function isMessageProcessed(messageKey) {
+  if (processedMessages.has(messageKey)) {
+    console.log(`[Slack] Duplicate event detected: ${messageKey}`);
+    return true;
+  }
+  processedMessages.add(messageKey);
+  setTimeout(() => processedMessages.delete(messageKey), MESSAGE_DEDUP_TTL);
+  console.log(`[Slack] Processing new message: ${messageKey}`);
+  return false;
+}
+var rateLimitMap = new Map;
+var RATE_LIMIT_WINDOW = 60000;
+var MAX_REQUESTS_PER_WINDOW = 10;
+function checkRateLimit(userId) {
+  const userRequests = rateLimitMap.get(userId) || 0;
+  if (userRequests >= MAX_REQUESTS_PER_WINDOW) {
+    return false;
+  }
+  rateLimitMap.set(userId, userRequests + 1);
+  setTimeout(() => {
+    const current = rateLimitMap.get(userId) || 0;
+    if (current > 0) {
+      rateLimitMap.set(userId, current - 1);
+    }
+  }, RATE_LIMIT_WINDOW);
+  return true;
+}
+function registerMessageHandler(app) {
+  app.event("message", async ({ event, body, client, say }) => {
+    let __stack2 = [];
+    try {
+      const eventId = body?.event_id;
+      if (wasEventSeen(eventId)) {
+        console.log(`[Slack] dropping Slack retry: event_id=${eventId}`);
+        return;
+      }
+      const msg = event;
+      if (msg.subtype === "message_changed")
+        return;
+      if (!cachedBotUserId) {
+        try {
+          const authResult = await client.auth.test();
+          cachedBotUserId = authResult.user_id;
+          cachedBotId = authResult.bot_id ?? null;
+        } catch (error) {
+          console.error("[Slack] Failed to cache bot user ID:", error);
+        }
+      }
+      if (isBotMessage(msg, cachedBotUserId)) {
+        return;
+      }
+      const hasText = !!msg.text?.trim();
+      const hasFiles = !!(msg.files && msg.files.length > 0);
+      if (!hasText && !hasFiles || !msg.user)
+        return;
+      const messageKey = `${msg.channel}:${msg.ts}`;
+      if (isMessageProcessed(messageKey)) {
+        return;
+      }
+      if (!await isUserAllowed(client, msg.user)) {
+        console.log(`[Slack] Ignoring message from unauthorized user ${msg.user}`);
+        return;
+      }
+      const requestedByUserId = await resolveSlackUserId(client, msg.user, {
+        sampleEventType: "message",
+        sampleContext: msg.text ?? ""
+      });
+      workflowEventBus.emit("slack.message", {
+        channel: msg.channel,
+        text: msg.text,
+        user: msg.user,
+        ts: msg.ts,
+        threadTs: msg.thread_ts
+      });
+      const effectiveText = buildEffectiveText(msg.text, msg.files);
+      if (!cachedBotUserId) {
+        console.error("[Slack] Bot user ID unavailable — skipping message to avoid silent misbehavior");
+        return;
+      }
+      const botUserId = cachedBotUserId;
+      const botMentioned = !!msg.text?.includes(`<@${botUserId}>`);
+      const isAssistantThread = !!msg.assistant_thread;
+      const isImplicitMention = isAssistantThread && !botMentioned && !hasOtherUserMention(effectiveText, botUserId);
+      const additiveSlack = isEnvFlagEnabled("ADDITIVE_SLACK", false);
+      const requireMentionForThreadFollowup = isEnvFlagEnabled("SLACK_THREAD_FOLLOWUP_REQUIRE_MENTION", false);
+      if (additiveSlack && msg.thread_ts) {
+        const unattached2 = bufferedFileFailures(msg.files);
+        const stripped = buildEffectiveText(msg.text, msg.files, unattached2).replace(/<@[A-Z0-9]+>/g, "").trim();
+        if (stripped.startsWith("!now") && await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts)) {
+          const nowMessage = stripped.replace(/^!now\s*/, "").trim();
+          const threadKey = `${msg.channel}:${msg.thread_ts}`;
+          console.log(`[Slack] !now command detected in thread ${threadKey}${nowMessage ? ` with message: "${nowMessage}"` : ""}`);
+          if (nowMessage) {
+            bufferThreadMessage(msg.channel, msg.thread_ts, nowMessage, msg.user, msg.ts);
+          }
+          await instantFlush(threadKey);
+          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("now"), "now");
+          await notifySlackFileFailures(client, msg.channel, msg.thread_ts, unattached2);
+          return;
+        }
+      }
+      if (additiveSlack && !botMentioned && msg.thread_ts && !requireMentionForThreadFollowup) {
+        if (hasOtherUserMention(effectiveText, botUserId)) {
+          console.log(`[Slack] Skipping ADDITIVE buffer in ${msg.channel}/${msg.thread_ts}: message mentions another user`);
+          return;
+        }
+        const hasSwarmActivity = await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts);
+        if (hasSwarmActivity) {
+          const threadKey = `${msg.channel}:${msg.thread_ts}`;
+          const unattached2 = bufferedFileFailures(msg.files);
+          bufferThreadMessage(msg.channel, msg.thread_ts, buildEffectiveText(msg.text, msg.files, unattached2), msg.user, msg.ts);
+          const count = getBufferMessageCount(threadKey);
+          const event2 = count === 1 ? "accepted" : "buffered";
+          const name = reactionName(event2);
+          console.log(`[Slack] Additive buffer: ${threadKey} (message #${count}, reaction: ${name})`);
+          await ackSlackMessage(client, msg.channel, msg.ts, name, event2);
+          await notifySlackFileFailures(client, msg.channel, msg.thread_ts, unattached2);
+          return;
+        }
+      }
+      const routingText = msg.text || effectiveText;
+      const routingThreadContext = msg.thread_ts ? { channelId: msg.channel, threadTs: msg.thread_ts } : undefined;
+      const matches = await routeMessage(routingText, botUserId, botMentioned || isImplicitMention, routingThreadContext);
+      if (matches.length === 0) {
+        let __stack = [];
+        try {
+          if (!botMentioned && !isImplicitMention)
+            return;
+          if (!checkRateLimit(msg.user)) {
+            if (!isSlackRenderV2Enabled()) {
+              await say({
+                text: ":satellite: _You're sending too many requests. Please slow down._",
+                thread_ts: msg.thread_ts || msg.ts
+              });
+            }
+            return;
+          }
+          const inbound2 = __using(__stack, await fetchSlackFiles(client, msg.files), 1);
+          const taskText = buildEffectiveText(msg.text, inbound2.files, inbound2.failed);
+          const taskDescription2 = isImplicitMention ? taskText : extractTaskFromMessage(taskText, botUserId);
+          if (!taskDescription2) {
+            if (!isImplicitMention && !isSlackRenderV2Enabled()) {
+              await say({
+                text: ":satellite: _Please provide a task description after mentioning an agent._",
+                thread_ts: msg.thread_ts || msg.ts
+              });
+            }
+            return;
+          }
+          const threadTs2 = msg.thread_ts || msg.ts;
+          const threadContext2 = await getThreadContext(client, msg.channel, msg.thread_ts, msg.ts, botUserId);
+          let fullTaskDescription2;
+          if (threadContext2) {
+            const ctxResult = resolveTemplate("slack.message.thread_context", {
+              thread_messages: threadContext2
+            });
+            fullTaskDescription2 = `${ctxResult.text}
+
+${taskDescription2}`;
+          } else {
+            fullTaskDescription2 = taskDescription2;
+          }
+          const lead = await getLeadAgent();
+          const { task, unattached: unattached2 } = await createSlackTaskWithFiles(fullTaskDescription2, {
+            agentId: lead?.id,
+            source: "slack",
+            slackChannelId: msg.channel,
+            slackThreadTs: threadTs2,
+            slackTriggerMessageTs: msg.ts,
+            slackUserId: msg.user,
+            requestedByUserId,
+            contextKey: slackContextKey({ channelId: msg.channel, threadTs: threadTs2 })
+          }, inbound2);
+          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
+          await notifySlackFileFailures(client, msg.channel, threadTs2, unattached2);
+          if (isSlackRenderV2Enabled()) {
+            await ensureSlackThreadTree([task.id]);
+          } else {
+            await say({
+              text: ":satellite: _No agents are online right now. Your request has been queued and will be processed when agents come back up._",
+              thread_ts: threadTs2
+            });
+          }
+          return;
+        } catch (_catch) {
+          var _err = _catch, _hasErr = 1;
+        } finally {
+          var _promise = __callDispose(__stack, _err, _hasErr);
+          _promise && await _promise;
+        }
+      }
+      if (!checkRateLimit(msg.user)) {
+        if (!isSlackRenderV2Enabled()) {
+          await say({
+            text: ":satellite: _You're sending too many requests. Please slow down._",
+            thread_ts: msg.thread_ts || msg.ts
+          });
+        }
+        return;
+      }
+      const inbound = __using(__stack2, await fetchSlackFiles(client, msg.files), 1);
+      const taskDescription = extractTaskFromMessage(buildEffectiveText(msg.text, inbound.files, inbound.failed), botUserId);
+      if (!taskDescription) {
+        if (!isSlackRenderV2Enabled()) {
+          await say({
+            text: ":satellite: _Please provide a task description after mentioning an agent._",
+            thread_ts: msg.thread_ts || msg.ts
+          });
+        }
+        return;
+      }
+      const threadTs = msg.thread_ts || msg.ts;
+      const threadContext = await getThreadContext(client, msg.channel, msg.thread_ts, msg.ts, botUserId);
+      let fullTaskDescription;
+      if (threadContext) {
+        const ctxResult = resolveTemplate("slack.message.thread_context", {
+          thread_messages: threadContext
+        });
+        fullTaskDescription = `${ctxResult.text}
+
+${taskDescription}`;
+      } else {
+        fullTaskDescription = taskDescription;
+      }
+      const results = { assigned: [], queued: [], steered: [], failed: [] };
+      const unattached = [];
+      for (const match of matches) {
+        const agent = await getAgentById(match.agent.id);
+        if (!agent) {
+          results.failed.push({ agentName: match.agent.name, reason: "not found" });
+          continue;
+        }
+        try {
+          const latestTask = await getMostRecentTaskInThread(msg.channel, threadTs);
+          if (agent.isLead) {
+            const steering = msg.thread_ts && inbound.files.length === 0 ? await requestSlackThreadSteering({
+              channelId: msg.channel,
+              threadTs,
+              message: taskDescription,
+              messageTimestamps: [msg.ts],
+              requestedByUserId
+            }) : null;
+            if (steering) {
+              await ackSlackMessage(client, msg.channel, msg.ts, reactionName("steered"), "steered");
+              results.steered.push({
+                agentName: agent.name,
+                acknowledgement: formatSlackSteeringAck(steering.result)
+              });
+              continue;
+            }
+            const created2 = await createSlackTaskWithFiles(fullTaskDescription, {
+              agentId: agent.id,
+              source: "slack",
+              slackChannelId: msg.channel,
+              slackThreadTs: threadTs,
+              slackTriggerMessageTs: msg.ts,
+              slackUserId: msg.user,
+              parentTaskId: latestTask?.id,
+              requestedByUserId,
+              contextKey: slackContextKey({ channelId: msg.channel, threadTs })
+            }, inbound);
+            const { task: task2 } = created2;
+            unattached.push(...created2.unattached);
+            await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
+            results.assigned.push({ agentName: agent.name, taskId: task2.id });
+            continue;
+          }
+          const created = await createSlackTaskWithFiles(fullTaskDescription, {
+            agentId: agent.id,
+            source: "slack",
+            slackChannelId: msg.channel,
+            slackThreadTs: threadTs,
+            slackTriggerMessageTs: msg.ts,
+            slackUserId: msg.user,
+            requestedByUserId,
+            contextKey: slackContextKey({ channelId: msg.channel, threadTs })
+          }, inbound);
+          const { task } = created;
+          unattached.push(...created.unattached);
+          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
+          const agentTasks = await getTasksByAgentId(agent.id);
+          const inProgressInThread = agentTasks.find((t) => t.id !== task.id && t.status === "in_progress" && t.slackThreadTs === threadTs);
+          if (inProgressInThread) {
+            results.queued.push({ agentName: agent.name, taskId: task.id });
+          } else {
+            results.assigned.push({ agentName: agent.name, taskId: task.id });
+          }
+        } catch {
+          results.failed.push({ agentName: agent.name, reason: "error" });
+        }
+      }
+      if (results.assigned.length + results.queued.length > 0) {
+        await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
+      }
+      const totalResults = results.assigned.length + results.queued.length + results.failed.length;
+      if (totalResults > 0) {
+        const successfulTaskIds = [...results.assigned, ...results.queued].map(({ taskId }) => taskId);
+        if (isSlackRenderV2Enabled()) {
+          if (successfulTaskIds.length > 0)
+            await ensureSlackThreadTree(successfulTaskIds);
+        } else {
+          const initialNodes = results.assigned.map(({ agentName, taskId }) => ({
+            taskId,
+            agentName,
+            status: "in_progress",
+            children: []
+          }));
+          for (const q of results.queued) {
+            initialNodes.push({
+              taskId: q.taskId,
+              agentName: q.agentName,
+              status: "pending",
+              children: []
+            });
+          }
+          const blocks = buildTreeBlocks(initialNodes);
+          if (results.failed.length > 0) {
+            const failedLines = results.failed.map((f) => `⚠️ Could not assign to: *${f.agentName}* — ${f.reason}`).join(`
+`);
+            blocks.push({
+              type: "context",
+              elements: [{ type: "mrkdwn", text: failedLines }]
+            });
+          }
+          const parts = [];
+          if (results.assigned.length > 0) {
+            const names = results.assigned.map((a) => `${a.agentName}`).join(", ");
+            parts.push(`Task assigned to: ${names}`);
+          }
+          if (results.queued.length > 0) {
+            const names = results.queued.map((q) => `${q.agentName}`).join(", ");
+            parts.push(`Task queued for: ${names}`);
+          }
+          if (results.failed.length > 0) {
+            const names = results.failed.map((f) => `${f.agentName}`).join(", ");
+            parts.push(`Could not assign to: ${names}`);
+          }
+          console.log(`[Slack] Posting initial tree message with ${initialNodes.length} node(s)${results.failed.length > 0 ? ` and ${results.failed.length} failed assignment(s)` : ""}`);
+          const resp = await say({
+            text: parts.join(". "),
+            blocks,
+            thread_ts: msg.thread_ts || msg.ts
+          });
+          if (resp?.ts) {
+            for (const { taskId } of results.assigned) {
+              await registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
+            }
+            for (const { taskId } of results.queued) {
+              await registerTreeMessage(taskId, msg.channel, threadTs, resp.ts);
+            }
+          }
+        }
+      }
+      if (!isSlackRenderV2Enabled()) {
+        for (const steered of results.steered) {
+          await say({
+            text: `${steered.acknowledgement} *${steered.agentName}* will receive it.`,
+            thread_ts: threadTs
+          });
+        }
+      }
+    } catch (_catch2) {
+      var _err2 = _catch2, _hasErr2 = 1;
+    } finally {
+      var _promise2 = __callDispose(__stack2, _err2, _hasErr2);
+      _promise2 && await _promise2;
+    }
+  });
+  app.event("app_mention", async ({ event }) => {
+    console.log(`[Slack] App mentioned in channel ${event.channel}`);
+  });
+}
+export {
+  checkUserAccess,
+  isBotMessage,
+  isSwarmThreadRoot,
+  registerMessageHandler,
+  resetSlackHandlerCachesForTesting
+};

package/dist/{hook-dcw4jfbj.js → hook-4nvqj2sb.js}

@@ -1,6 +1,7 @@
 import {
   handleHook
-} from "./cli-anktweqr.js";
+} from "./cli-89xfd7f9.js";
+import"./cli-d8brzxjb.js";
 import"./cli-rvqz34y5.js";
 import"./cli-hp1n6zq3.js";
 import"./cli-xvkmedgn.js";
@@ -8,15 +9,16 @@ import"./cli-1ebpar1q.js";
 import"./cli-e7d20cty.js";
 import"./cli-3dpj7atn.js";
 import"./cli-f14fvzag.js";
-import"./cli-fs1kkqgr.js";
+import"./cli-m9sxbkhm.js";
 import"./cli-bsakbbkm.js";
-import"./cli-kpev657q.js";
-import"./cli-7fnkj1hj.js";
+import"./cli-9d8ntetj.js";
+import"./cli-y6b6fb76.js";
+import"./cli-kpv03zhj.js";
 import"./cli-e29gmdmw.js";
 import"./cli-ej6gbxfb.js";
 import"./cli-sd0mxa3c.js";
 import"./cli-w5e1d1vv.js";
-import"./cli-dc9k2ba9.js";
+import"./cli-w9kb3bk1.js";
 import"./cli-xqcq9y5e.js";
 import"./cli-c4eeb5q2.js";
 import"./cli-btbzvq95.js";