@thinkingai/ae-cli 6.0.37 → 6.0.39

package/dist/{chunk-HQ2A7ITL.js → chunk-RBNKI5ZW.js}

@@ -1,16 +1,16 @@
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-E7UXXHO3.js";
+} from "./chunk-Z3OXWCIA.js";
 import {
   safeJsonParse
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 import {
   PermissionError
-} from "./chunk-24BAVOX3.js";
+} from "./chunk-AXDXJTPC.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-JHENBQ5B.js";
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";
@@ -52,6 +52,14 @@ async function permissionMessage(resp) {
   }
   return "Permission denied for this resource (HTTP 403)";
 }
+async function permissionError(resp) {
+  const codeResponse = resp.clone();
+  const message = await permissionMessage(resp);
+  const body = safeJsonParse(await codeResponse.text());
+  const error = isRecord(body?.error) ? body.error : void 0;
+  const code = nonEmptyString(error?.code) ?? nonEmptyString(body?.code);
+  return new PermissionError(message, code);
+}
 function isInvalidCliTokenMessage(message) {
   return /\byour token is invalid\b/i.test(message) || /\bcli[-_\s]?token\b.*\binvalid\b/i.test(message) || /\binvalid\b.*\bcli[-_\s]?token\b/i.test(message);
 }
@@ -147,22 +155,26 @@ async function requestMultipartOnce(url, token, form) {
     body: form
   });
 }
-async function callGateway(host, domain, pathAfterV1, method, body, queryParams = {}) {
-  return (await callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams)).data;
+async function callGateway(host, domain, pathAfterV1, method, body, queryParams = {}, options = {}) {
+  return (await callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams, options)).data;
 }
-async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams = {}) {
-  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams);
+async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams = {}, options = {}) {
+  const url = buildCapabilityGatewayUrl(options.apiBaseUrl ?? host, domain, pathAfterV1, queryParams);
   const token = await getCliToken(host);
   let resp = await requestOnce(url, method, token, body);
   let permissionMsg;
   if (resp.status === 403) {
-    permissionMsg = await permissionMessage(resp);
+    const error = await permissionError(resp);
+    permissionMsg = error.message;
     if (!isInvalidCliTokenMessage(permissionMsg)) {
-      throw new PermissionError(permissionMsg);
+      throw error;
     }
   }
-  if (resp.status === 401 || resp.status === 403 && permissionMsg) {
-    logger.warn(`Capability gateway request failed (${resp.status === 403 ? permissionMsg : "HTTP 401"}) for ${host}, refreshing CLI token`);
+  if (resp.status === 401) {
+    if (options.retryOnUnauthorized === false) {
+      await throwCapabilityHttpError(resp);
+    }
+    logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
     clearCliToken(host);
     const newToken = await getCliToken(host);
     process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
@@ -174,6 +186,19 @@ async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body,
     if (!resp.ok) {
       await throwCapabilityHttpError(resp);
     }
+  } else if (resp.status === 403 && permissionMsg) {
+    logger.warn(`Capability gateway request failed (${permissionMsg}) for ${host}, refreshing CLI token`);
+    clearCliToken(host);
+    const newToken = await getCliToken(host);
+    process.stderr.write(`[ae-cli] CLI token refreshed for ${host}
+`);
+    resp = await requestOnce(url, method, newToken, body);
+    if (resp.status === 403) {
+      throw await permissionError(resp);
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
   } else if (!resp.ok) {
     await throwCapabilityHttpError(resp);
   }
@@ -184,7 +209,7 @@ async function fetchCapabilityGateway(host, domain, pathAfterV1, method = "GET",
   const token = await getCliToken(host);
   let resp = await requestOnce(url, method, token, body, accept);
   if (resp.status === 403) {
-    throw new PermissionError(await permissionMessage(resp));
+    throw await permissionError(resp);
   }
   if (resp.status === 401) {
     logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
@@ -194,7 +219,7 @@ async function fetchCapabilityGateway(host, domain, pathAfterV1, method = "GET",
 `);
     resp = await requestOnce(url, method, newToken, body, accept);
     if (resp.status === 403) {
-      throw new PermissionError(await permissionMessage(resp));
+      throw await permissionError(resp);
     }
     if (!resp.ok) {
       await throwCapabilityHttpError(resp);
@@ -273,7 +298,7 @@ async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, fil
   const token = await getCliToken(host);
   let resp = await requestMultipartOnce(url, token, form);
   if (resp.status === 403) {
-    throw new PermissionError(await permissionMessage(resp));
+    throw await permissionError(resp);
   }
   if (resp.status === 401) {
     logger.warn(`Capability gateway request failed (HTTP 401) for ${host}, refreshing CLI token`);
@@ -283,7 +308,7 @@ async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, fil
 `);
     resp = await requestMultipartOnce(url, newToken, form);
     if (resp.status === 403) {
-      throw new PermissionError(await permissionMessage(resp));
+      throw await permissionError(resp);
     }
     if (!resp.ok) {
       await throwCapabilityHttpError(resp);
@@ -293,6 +318,13 @@ async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, fil
   }
   return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
 }
+async function callCapabilityApi(host, domain, action, method = "POST", params = {}, options = {}) {
+  const isGet = method === "GET";
+  if (isGet) {
+    return callGateway(host, domain, action.replace(/^\/+|\/+$/g, ""), "GET", void 0, {}, options);
+  }
+  return callGateway(host, domain, action.replace(/^\/+|\/+$/g, ""), method, params, {}, options);
+}
 
 export {
   CapabilityGatewayError,
@@ -307,5 +339,6 @@ export {
   dryRunCapability,
   validateCapability,
   uploadInputFile,
-  uploadInputFileBytes
+  uploadInputFileBytes,
+  callCapabilityApi
 };

package/dist/{chunk-LHVM35J4.js → chunk-TS6BUGUY.js}

@@ -1,14 +1,14 @@
 import {
   resolveGatewayDomain
 } from "./chunk-PTE56QPL.js";
+import {
+  withOutputMetadata
+} from "./chunk-YTG6Q75E.js";
 import {
   dryRunCapability,
   executeCapabilityWithEnvelope,
   validateCapability
-} from "./chunk-RGXCNC4N.js";
-import {
-  withOutputMetadata
-} from "./chunk-KTYR3U6D.js";
+} from "./chunk-GS2P7LFD.js";
 
 // src/core/capability-command.ts
 import { randomBytes } from "crypto";

package/dist/chunk-TUKQZTMI.js

@@ -0,0 +1,250 @@
+// src/core/multiselect.ts
+var MultiselectCancelled = class extends Error {
+  constructor() {
+    super("Selection cancelled by user");
+    this.name = "MultiselectCancelled";
+  }
+};
+function buildRows(items) {
+  const rows = [];
+  let lastGroup;
+  for (let i = 0; i < items.length; i++) {
+    const it = items[i];
+    if (it.group && it.group !== lastGroup) {
+      rows.push({ kind: "header", groupLabel: it.group });
+      lastGroup = it.group;
+    }
+    rows.push({ kind: "item", itemIndex: i, item: it });
+  }
+  return rows;
+}
+function promptMultiselect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) {
+    return Promise.resolve([]);
+  }
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    return Promise.reject(
+      new Error("ae-cli sync requires a TTY for multi-select; please run in an interactive terminal")
+    );
+  }
+  const rows = buildRows(items);
+  const itemRowIndices = [];
+  rows.forEach((r, idx) => {
+    if (r.kind === "item") itemRowIndices.push(idx);
+  });
+  const selected = /* @__PURE__ */ new Set();
+  items.forEach((it, idx) => {
+    if (it.preselected) selected.add(idx);
+  });
+  let cursorRowIdx = itemRowIndices[0];
+  let renderCount = 0;
+  function totalLines() {
+    return rows.length + 2;
+  }
+  function render() {
+    if (renderCount > 0) {
+      stderr.write(`\x1B[${totalLines()}A`);
+    }
+    stderr.write(`${title}  (space: select \xB7 a: select all/none \xB7 enter: confirm \xB7 q: cancel)\x1B[K
+`);
+    stderr.write(`\x1B[K
+`);
+    rows.forEach((row, ridx) => {
+      if (row.kind === "header") {
+        stderr.write(`  \x1B[90m\u2500\u2500 ${row.groupLabel} \u2500\u2500\x1B[0m\x1B[K
+`);
+        return;
+      }
+      const isCursor = ridx === cursorRowIdx;
+      const isSelected = selected.has(row.itemIndex);
+      const pointer = isCursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const checkbox = isSelected ? "\x1B[32m[x]\x1B[0m" : "[ ]";
+      const label = row.item.label;
+      const hint = row.item.hint ? ` \x1B[90m${row.item.hint}\x1B[0m` : "";
+      stderr.write(`${pointer} ${checkbox} ${label}${hint}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function moveCursor(direction) {
+      const cur = itemRowIndices.indexOf(cursorRowIdx);
+      const next = (cur + direction + itemRowIndices.length) % itemRowIndices.length;
+      cursorRowIdx = itemRowIndices[next];
+      render();
+    }
+    function toggleAll() {
+      if (selected.size === items.length) {
+        selected.clear();
+      } else {
+        items.forEach((_, idx) => selected.add(idx));
+      }
+      render();
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        moveCursor(-1);
+      } else if (key === "\x1B[B" || key === "j") {
+        moveCursor(1);
+      } else if (key === " ") {
+        const row = rows[cursorRowIdx];
+        if (row.kind === "item") {
+          const idx = row.itemIndex;
+          if (selected.has(idx)) selected.delete(idx);
+          else selected.add(idx);
+          render();
+        }
+      } else if (key === "a" || key === "A") {
+        toggleAll();
+      } else if (key === "\r" || key === "\n") {
+        if (selected.size === 0) {
+          stderr.write("\x07");
+          return;
+        }
+        cleanup();
+        const result = Array.from(selected).map((i) => items[i].value);
+        resolve(result);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+function promptSingleCheckboxSelect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) return Promise.reject(new Error("No items to select"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("A TTY is required for single-select"));
+  const preselectedIndex = items.findIndex((item) => item.preselected);
+  let cursor = preselectedIndex >= 0 ? preselectedIndex : 0;
+  let selected = preselectedIndex >= 0 ? preselectedIndex : null;
+  let renderCount = 0;
+  const lines = items.length + 2;
+  function render() {
+    if (renderCount > 0) stderr.write(`\x1B[${lines}A`);
+    stderr.write(`${title}  (space: select \xB7 enter: confirm \xB7 q: cancel)\x1B[K
+`);
+    stderr.write(`\x1B[K
+`);
+    items.forEach((it, idx) => {
+      const pointer = idx === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      const checkbox = selected === idx ? "\x1B[32m[x]\x1B[0m" : "[ ]";
+      const hint = it.hint ? ` \x1B[90m${it.hint}\x1B[0m` : "";
+      stderr.write(`${pointer} ${checkbox} ${it.label}${hint}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function moveCursor(direction) {
+      cursor = (cursor + direction + items.length) % items.length;
+      render();
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        moveCursor(-1);
+      } else if (key === "\x1B[B" || key === "j") {
+        moveCursor(1);
+      } else if (key === " ") {
+        selected = cursor;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        if (selected === null) {
+          stderr.write("\x07");
+          return;
+        }
+        cleanup();
+        resolve(items[selected].value);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+function promptSingleSelect(opts) {
+  const { title, items } = opts;
+  if (items.length === 0) return Promise.reject(new Error("No items to select"));
+  const stderr = process.stderr;
+  const stdin = process.stdin;
+  if (!stdin.isTTY) return Promise.reject(new Error("A TTY is required for single-select"));
+  let cursor = 0;
+  let renderCount = 0;
+  const lines = items.length + 1;
+  function render() {
+    if (renderCount > 0) stderr.write(`\x1B[${lines}A`);
+    stderr.write(`${title}\x1B[K
+`);
+    items.forEach((it, idx) => {
+      const pointer = idx === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      stderr.write(`${pointer} ${it.label}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve, reject) => {
+    stderr.write("\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        cleanup();
+        resolve(items[cursor].value);
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        reject(new MultiselectCancelled());
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+
+export {
+  MultiselectCancelled,
+  promptMultiselect,
+  promptSingleCheckboxSelect,
+  promptSingleSelect
+};

package/dist/{chunk-J7MZHDHQ.js → chunk-VKD5WQKN.js}

@@ -1,7 +1,7 @@
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
@@ -147,8 +147,8 @@ async function signRequest(method, path, rawBody, hostOverride) {
       rawBody
     };
   }
-  const { getToken } = await import("./auth-ENM3FE6L.js");
-  const { getCliToken } = await import("./cli-token-4SBMXAUK.js");
+  const { getToken } = await import("./auth-NN55553T.js");
+  const { getCliToken } = await import("./cli-token-GL5MS5FK.js");
   const baseUrl = hostOverride ? teClaudeBaseFromActiveHost(hostOverride) : sandboxCred?.url || teClaudeBaseFromActiveHost();
   if (!baseUrl) {
     throw new TeAgentCredentialsError(
@@ -338,8 +338,8 @@ async function uploadToMainApp(path, formData, hostOverride) {
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
   } else {
-    const { getToken } = await import("./auth-ENM3FE6L.js");
-    const { getCliToken } = await import("./cli-token-4SBMXAUK.js");
+    const { getToken } = await import("./auth-NN55553T.js");
+    const { getCliToken } = await import("./cli-token-GL5MS5FK.js");
     baseUrl = (hostOverride ? teClaudeBaseFromActiveHost(hostOverride) : sandboxCred?.url || teClaudeBaseFromActiveHost())?.replace(/\/$/, "") || "";
     if (!baseUrl) {
       throw new TeAgentCredentialsError(

package/dist/{chunk-3KI3RRXX.js → chunk-VTXHDCBW.js}

@@ -1,12 +1,12 @@
 import {
   getCliToken
-} from "./chunk-E7UXXHO3.js";
+} from "./chunk-Z3OXWCIA.js";
 import {
   safeJsonParse
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 import {
   PermissionError
-} from "./chunk-24BAVOX3.js";
+} from "./chunk-AXDXJTPC.js";
 
 // src/core/mcp-access.ts
 function buildUrl(host, path, params = {}) {

package/dist/{chunk-KTYR3U6D.js → chunk-YTG6Q75E.js}

@@ -1,18 +1,18 @@
 import {
   peekCliToken
-} from "./chunk-E7UXXHO3.js";
+} from "./chunk-Z3OXWCIA.js";
 import {
   getToken
-} from "./chunk-IR4ZLVPW.js";
+} from "./chunk-YV52FB5G.js";
 import {
   getActiveHost,
   getConfigDir,
   isAeSandboxRuntime,
   normalizeUrl
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-JHENBQ5B.js";
 
 // src/core/version-sync.ts
 import { spawnSync } from "child_process";
@@ -23,9 +23,13 @@ import path from "path";
 function shouldSkipUpdateCheck(argv = process.argv) {
   if (process.env.AE_CLI_NO_UPDATE_CHECK === "1") return true;
   if (process.env.CI === "true" || process.env.CI === "1") return true;
-  return argv.slice(2).some((arg) => {
+  return argv.slice(2).some((arg, index, args) => {
     if (arg === "--no-update-check") return true;
-    if (arg === "--version" || arg === "-V" || arg === "--help" || arg === "-h") return true;
+    if (arg === "--version") {
+      const value = args[index + 1];
+      return !value || value.startsWith("-");
+    }
+    if (arg === "-V" || arg === "--help" || arg === "-h") return true;
     return false;
   });
 }

package/dist/{chunk-IR4ZLVPW.js → chunk-YV52FB5G.js}

@@ -3,10 +3,10 @@ import {
   getConfigDir,
   normalizeUrl,
   safeJsonParse
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-JHENBQ5B.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";
@@ -233,6 +233,25 @@ var SecureStoreAuthError = class extends Error {
   }
 };
 
+// src/core/host-guidance.ts
+var AE_TRIAL_URL = "https://thinkingai.cn/request-demo";
+var AE_HOST_SETUP_COMMAND = "ae-cli config set-host <url>";
+function missingAeHostHint(additionalAction) {
+  const actions = [
+    `If your organization already uses AgenticEngine, ask your administrator for its AE URL, then run: ${AE_HOST_SETUP_COMMAND}.`,
+    `If you do not have an AgenticEngine environment, request a trial: ${AE_TRIAL_URL}`
+  ];
+  if (additionalAction) actions.push(additionalAction);
+  return actions.join(" ");
+}
+function missingAeHostGuidance() {
+  return {
+    configure_host: AE_HOST_SETUP_COMMAND,
+    existing_customer: "Ask your AgenticEngine administrator for the AE environment URL.",
+    request_trial_url: AE_TRIAL_URL
+  };
+}
+
 // src/core/auth.ts
 function resolveHost(hostOverride) {
   if (hostOverride) return normalizeUrl(hostOverride);
@@ -262,7 +281,7 @@ async function getToken(hostUrl) {
   if (!hostUrl) {
     throw new Error(
       `No AE host configured.
-Run: ae-cli config set-host <url>`
+` + missingAeHostHint()
     );
   }
   try {
@@ -288,6 +307,9 @@ export {
   clear,
   loadCliToken,
   SecureStoreAuthError,
+  AE_TRIAL_URL,
+  missingAeHostHint,
+  missingAeHostGuidance,
   resolveHost,
   validateToken,
   invalidateAccessTokenForRetry,

package/dist/{chunk-E7UXXHO3.js → chunk-Z3OXWCIA.js}

@@ -3,7 +3,7 @@ import {
   load,
   loadCliToken,
   save
-} from "./chunk-IR4ZLVPW.js";
+} from "./chunk-YV52FB5G.js";
 import {
   getActiveHost,
   getConfigDir,
@@ -12,10 +12,10 @@ import {
   normalizeUrl,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-V6FR6WTW.js";
+} from "./chunk-GJJA4CQZ.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-JHENBQ5B.js";
 
 // src/core/cli-token.ts
 import fs from "fs";

package/dist/{cli-token-4SBMXAUK.js → cli-token-GL5MS5FK.js}

@@ -6,10 +6,10 @@ import {
   mintCliToken,
   peekCliToken,
   setCliTokenManual
-} from "./chunk-E7UXXHO3.js";
-import "./chunk-IR4ZLVPW.js";
-import "./chunk-V6FR6WTW.js";
-import "./chunk-LYVNONC4.js";
+} from "./chunk-Z3OXWCIA.js";
+import "./chunk-YV52FB5G.js";
+import "./chunk-GJJA4CQZ.js";
+import "./chunk-JHENBQ5B.js";
 export {
   _resetRenewMemoryForTest,
   clearCliToken,

package/dist/{client-PP5FETMW.js → client-DAIPF7XN.js}

@@ -7,10 +7,10 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-DB4Q3ANU.js";
-import "./chunk-IR4ZLVPW.js";
-import "./chunk-V6FR6WTW.js";
-import "./chunk-LYVNONC4.js";
+} from "./chunk-6A2FUCIS.js";
+import "./chunk-YV52FB5G.js";
+import "./chunk-GJJA4CQZ.js";
+import "./chunk-JHENBQ5B.js";
 export {
   httpDelete,
   httpGet,

package/dist/{community-report-client-KK2QBANO.js → community-report-client-M2RW4MXD.js}

@@ -1,9 +1,9 @@
 import {
   CommunityReportError
-} from "./chunk-24BAVOX3.js";
+} from "./chunk-AXDXJTPC.js";
 import {
   logger
-} from "./chunk-LYVNONC4.js";
+} from "./chunk-JHENBQ5B.js";
 
 // src/core/community-report-client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;