@thinkingai/ae-cli 6.0.54 → 6.0.56

package/dist/{chunk-GIK6EDUG.js → chunk-P7KL7IOH.js}

@@ -3,14 +3,17 @@ import {
   getActiveHost,
   getConfigDir,
   getFallbackCliToken,
-  normalizeUrl,
+  readSandboxCliTokenEntry,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-UQ77JXYH.js";
+} from "./chunk-LMCYSVVA.js";
 import {
   PermissionError,
-  logger
-} from "./chunk-WNGFSIOB.js";
+  externalCliTokenRequestOptions,
+  logger,
+  normalizeUrl,
+  readExternalCliToken
+} from "./chunk-ZW4VMY5H.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";
@@ -696,7 +699,8 @@ async function validateCliTokenOnServer(hostUrl, cliToken) {
   try {
     resp = await fetch(url, {
       method: "GET",
-      headers: { Accept: "application/json", "cli-token": cliToken }
+      headers: { Accept: "application/json", "cli-token": cliToken },
+      ...externalCliTokenRequestOptions(url)
     });
   } catch (error) {
     throw new CliTokenValidationUnavailableError(`Unable to validate CLI token for ${hostUrl}: ${error.message}`);
@@ -734,10 +738,14 @@ async function validateCliTokenOnServer(hostUrl, cliToken) {
     ...cliTokenExpiresAt ? { cliTokenExpiresAt } : {}
   };
 }
-async function renewCliTokenOnServer(hostUrl, cliToken) {
+async function renewCliTokenOnServer(hostUrl, cliToken, external = false) {
   const url = new URL(`${hostUrl.replace(/\/+$/, "")}${CLI_TOKEN_RENEW_PATH}`);
-  url.searchParams.set("cli-token", cliToken);
-  const resp = await fetch(url.toString(), { method: "GET", headers: { Accept: "application/json" } });
+  if (!external) url.searchParams.set("cli-token", cliToken);
+  const resp = await fetch(url.toString(), {
+    method: "GET",
+    headers: { Accept: "application/json", ...external ? { "cli-token": cliToken } : {} },
+    ...externalCliTokenRequestOptions(url.toString())
+  });
   const text = await resp.text();
   let data;
   try {
@@ -750,10 +758,10 @@ async function renewCliTokenOnServer(hostUrl, cliToken) {
     throw new Error(`CLI token renew error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
   }
 }
-async function maybeRenewCliTokenDaily(hostUrl, cliToken) {
+async function maybeRenewCliTokenDaily(hostUrl, cliToken, external = false) {
   const key = renewKey(hostUrl, cliToken);
   const today = localRenewDate();
-  if (renewedLocalDate.get(key) === today || persistedRenewDate(hostUrl, cliToken) === today) {
+  if (renewedLocalDate.get(key) === today || !external && persistedRenewDate(hostUrl, cliToken) === today) {
     renewedLocalDate.set(key, today);
     return;
   }
@@ -761,11 +769,12 @@ async function maybeRenewCliTokenDaily(hostUrl, cliToken) {
   if (existing) return existing;
   const attempt = (async () => {
     try {
-      await renewCliTokenOnServer(hostUrl, cliToken);
-      markRenewSucceeded(hostUrl, cliToken, today);
+      await renewCliTokenOnServer(hostUrl, cliToken, external);
+      if (external) renewedLocalDate.set(key, today);
+      else markRenewSucceeded(hostUrl, cliToken, today);
       logger.info(`cli-token: renewed for ${normalizeUrl(hostUrl)} (local day ${today})`);
     } catch (error) {
-      logger.warn(`cli-token: renew failed for ${normalizeUrl(hostUrl)}: ${error?.message || error}; business call proceeds`);
+      logger.warn(`cli-token: renew failed for ${normalizeUrl(hostUrl)}${external ? "" : `: ${error?.message || error}`}; business call proceeds`);
     } finally {
       renewInFlight.delete(key);
     }
@@ -774,6 +783,9 @@ async function maybeRenewCliTokenDaily(hostUrl, cliToken) {
   await attempt;
 }
 function peekCliToken(hostOverride) {
+  const external = readExternalCliToken(hostOverride);
+  if (external) return external.token;
+  if (process.env.TE_AGENT_CLI_CONFIG_DIR !== void 0) return sessionCliToken(hostOverride);
   const hostUrl = hostOverride || getActiveHost();
   if (!hostUrl) return void 0;
   const normalizedHost = normalizeUrl(hostUrl);
@@ -791,6 +803,16 @@ function peekCliToken(hostOverride) {
   return cliTokenCache.get(normalizedHost) || getFallbackCliToken(normalizedHost) || void 0;
 }
 async function getCliToken(hostOverride) {
+  const external = readExternalCliToken(hostOverride);
+  if (external) {
+    await maybeRenewCliTokenDaily(external.url, external.token, true);
+    return external.token;
+  }
+  if (process.env.TE_AGENT_CLI_CONFIG_DIR !== void 0) {
+    const token2 = sessionCliToken(hostOverride);
+    if (!token2) throw new SecureStoreAuthError("Current session CLI credential is unavailable or does not match the requested host.");
+    return token2;
+  }
   const resolvedHost = hostOverride || getActiveHost();
   if (!resolvedHost) throw new SecureStoreAuthError("No AE host configured. Run: ae-cli auth login --host <url>");
   const hostUrl = normalizeUrl(resolvedHost);
@@ -803,6 +825,12 @@ async function getCliToken(hostOverride) {
   await maybeRenewCliTokenDaily(hostUrl, token);
   return token;
 }
+function sessionCliToken(hostOverride) {
+  const entry = readSandboxCliTokenEntry();
+  if (!entry?.token.startsWith("cli_")) return void 0;
+  if (hostOverride && normalizeUrl(entry.url) !== normalizeUrl(hostOverride)) return void 0;
+  return entry.token;
+}
 async function mintCliToken(hostUrl, accessToken) {
   logger.info(`Generating CLI token for ${hostUrl}`);
   const cliToken = await generateCliToken(hostUrl, accessToken);

package/dist/{chunk-AP7YP2NX.js → chunk-QSAR3GHY.js}

@@ -5,14 +5,14 @@ import {
   require_node,
   require_process_nextick_args,
   require_util
-} from "./chunk-S6M42KND.js";
+} from "./chunk-T44M3PLZ.js";
 import {
   __commonJS,
   __esm,
   __export,
   __require,
   __toCommonJS
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // node_modules/readdir-glob/node_modules/minimatch/lib/path.js
 var require_path = __commonJS({

package/dist/{chunk-S6M42KND.js → chunk-T44M3PLZ.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   __commonJS,
   __require
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // node_modules/process-nextick-args/index.js
 var require_process_nextick_args = __commonJS({

package/dist/{chunk-HVHR4SCP.js → chunk-UUD5RB36.js}

@@ -9,15 +9,15 @@ import {
   postAgentApi,
   putAgentApi,
   uploadAgentApi
-} from "./chunk-4655PUNX.js";
+} from "./chunk-JJJIP2XQ.js";
 import {
   TeAgentApiError,
   createTeAgentApiError
-} from "./chunk-PLE722AJ.js";
+} from "./chunk-2UWS5CUP.js";
 import {
   CliValidationError,
   isApiErrorType
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // src/commands/workspace/client.ts
 var DEFAULT_TE_CLAUDE_BASE_PATH = "/agent";

package/dist/{chunk-HBLK3ZHW.js → chunk-W2PTY5NN.js}

@@ -6,15 +6,15 @@ import {
   CapabilityGatewayError,
   fetchCapabilityGateway,
   requestCapabilityGateway
-} from "./chunk-EOYSKMXN.js";
+} from "./chunk-MXV3PYC3.js";
 import {
   readOutputMetadata,
   unwrapOutputData,
   withOutputMetadata
-} from "./chunk-KFNMQTZI.js";
+} from "./chunk-ELCR235M.js";
 import {
   PermissionError
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // src/core/analysis-async-artifact.ts
 import { randomBytes } from "crypto";

package/dist/chunk-X7DRLE62.js

@@ -0,0 +1,233 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
+import {
+  CliValidationError,
+  logger
+} from "./chunk-ZW4VMY5H.js";
+
+// src/core/eval-endpoint.ts
+function resolveEvaluationHost(host) {
+  let endpoint;
+  try {
+    endpoint = new URL(host);
+    if (endpoint.username || endpoint.password || endpoint.search || endpoint.hash || /[?#\s]/.test(host)) throw new Error();
+  } catch {
+    throw new CliValidationError("Evaluation AE Host must be an absolute HTTP(S) URL without credentials, query, or fragment.", {
+      code: "EVAL_ENDPOINT_INVALID"
+    });
+  }
+  const hostname = endpoint.hostname.toLowerCase().replace(/^\[|\]$/g, "").replace(/\.$/, "");
+  const mappedIpv4 = /^::ffff:([0-9a-f]+):[0-9a-f]+$/.exec(hostname);
+  if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "::1" || hostname === "::" || hostname === "0.0.0.0" || hostname.startsWith("127.") || mappedIpv4 && parseInt(mappedIpv4[1], 16) >> 8 === 127 || hostname === "::ffff:0:0") {
+    throw new CliValidationError("Loopback evaluation endpoints are unsupported.", {
+      code: "EVAL_ENDPOINT_LOOPBACK_UNSUPPORTED",
+      hint: "Select an online AE Host with --host."
+    });
+  }
+  if (endpoint.protocol !== "http:" && endpoint.protocol !== "https:") {
+    throw new CliValidationError("Evaluation AE Host must use HTTP or HTTPS.", {
+      code: "EVAL_ENDPOINT_INVALID"
+    });
+  }
+  return endpoint.toString().replace(/\/+$/, "").replace(/\/agent$/, "");
+}
+
+// src/core/eval-client.ts
+import { open, unlink } from "fs/promises";
+import { resolve } from "path";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var EvalApiError = class extends Error {
+  code;
+  httpStatus;
+  hint;
+  details;
+  constructor(message, options) {
+    const redact = evaluationErrorRedactor([
+      ...options.sensitiveValues ?? [],
+      process.env.AE_EVAL_ACCESS_TOKEN ?? ""
+    ]);
+    super(redact(message));
+    this.name = "EvalApiError";
+    this.code = options.code;
+    this.httpStatus = options.httpStatus;
+    this.hint = options.hint === void 0 ? void 0 : redact(options.hint);
+    this.details = options.details === void 0 ? void 0 : redact(options.details);
+  }
+};
+function evaluationErrorRedactor(secrets) {
+  const forms = [...new Set(secrets.filter(Boolean).flatMap((secret) => [
+    secret,
+    JSON.stringify(secret).slice(1, -1),
+    encodeURIComponent(secret)
+  ]))].sort((a, b) => b.length - a.length);
+  const redact = (value) => {
+    if (typeof value === "string") {
+      for (const secret of forms) value = value.split(secret).join("[REDACTED]");
+      return value;
+    }
+    if (Array.isArray(value)) return value.map(redact);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).map(([key, item]) => [redact(key), redact(item)]));
+    }
+    return value;
+  };
+  return redact;
+}
+async function evalRequest(options) {
+  const url = buildEvalUrl(options.baseUrl, options.path, options.params);
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  const headers = {
+    ...options.headers,
+    Accept: options.responseType === "bytes" ? "application/octet-stream, application/json" : "application/json"
+  };
+  const isMultipart = options.body instanceof FormData;
+  if (options.body !== void 0 && !isMultipart) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (options.idempotencyKey) {
+    headers["Idempotency-Key"] = options.idempotencyKey;
+  }
+  let response;
+  let responseText = "";
+  let bytes;
+  try {
+    response = await fetchImpl(url, {
+      method: options.method,
+      headers,
+      body: options.body === void 0 ? void 0 : options.body instanceof FormData ? options.body : JSON.stringify(options.body),
+      redirect: "error",
+      signal: controller.signal
+    });
+    if (response.ok && options.responseType === "bytes") {
+      bytes = new Uint8Array(await response.arrayBuffer());
+    } else {
+      responseText = await response.text();
+    }
+  } catch (error) {
+    const timedOut = controller.signal.aborted || error instanceof Error && error.name === "AbortError";
+    logEvalRequest(options.method, url, response?.status ?? "unavailable");
+    if (timedOut) {
+      throw new EvalApiError(`Evaluation API request timed out after ${timeoutMs} ms.`, {
+        code: "EVAL_API_TIMEOUT",
+        httpStatus: 0,
+        hint: "Verify the evaluation platform is reachable at the configured endpoint."
+      });
+    }
+    throw new EvalApiError("Evaluation API request failed before a response was received.", {
+      code: "EVAL_API_NETWORK_ERROR",
+      httpStatus: 0,
+      hint: "Verify the --endpoint URL and network path."
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+  logEvalRequest(options.method, url, response.status);
+  if (bytes !== void 0) return bytes;
+  const responseBody = parseEvalResponseBody(responseText, response.status);
+  if (!response.ok) {
+    const sensitiveValues = Object.values(options.headers).flatMap((value) => [value, value.replace(/^Bearer\s+/i, "")]);
+    if (isRecord(options.body)) {
+      for (const key of ["secret", "data_token", "report_source"]) {
+        if (typeof options.body[key] === "string") sensitiveValues.push(options.body[key]);
+      }
+    }
+    throw evalErrorFromBody(responseBody, response.status, sensitiveValues);
+  }
+  return responseBody;
+}
+async function evalDownloadFile(options, outputPath) {
+  const path = resolve(outputPath);
+  let file;
+  try {
+    file = await open(path, "wx", 384);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      throw new CliValidationError("Output file already exists; choose a new --output path.", {
+        code: "EVAL_OUTPUT_EXISTS"
+      });
+    }
+    throw error;
+  }
+  let completed = false;
+  try {
+    const bytes = await evalRequest({ ...options, responseType: "bytes" });
+    await file.writeFile(bytes);
+    completed = true;
+    return { path, byte_size: bytes.byteLength };
+  } finally {
+    await file.close();
+    if (!completed) await unlink(path);
+  }
+}
+function buildEvalUrl(baseUrl, path, params) {
+  const base = resolveEvaluationHost(baseUrl);
+  const url = new URL(`${base}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0 || value === null || value === "") continue;
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function parseEvalResponseBody(text, httpStatus) {
+  if (!text.trim()) {
+    if (httpStatus === 204) return void 0;
+    throw new EvalApiError("Evaluation API returned an empty response body.", {
+      code: "EVAL_API_INVALID_RESPONSE",
+      httpStatus
+    });
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new EvalApiError("Evaluation API returned a non-JSON response body.", {
+      code: "EVAL_API_INVALID_RESPONSE",
+      httpStatus
+    });
+  }
+}
+function evalErrorFromBody(body, httpStatus, sensitiveValues) {
+  const error = body?.error;
+  if (isRecord(error) && typeof error.message === "string" && error.message.trim()) {
+    return new EvalApiError(error.message.trim(), {
+      code: typeof error.code === "string" && /^[A-Z][A-Z0-9_]{0,127}$/.test(error.code) ? error.code : `EVAL_API_HTTP_${httpStatus}`,
+      httpStatus,
+      hint: typeof error.details === "string" ? error.details : void 0,
+      details: isRecord(error.details) ? error.details : void 0,
+      sensitiveValues
+    });
+  }
+  return new EvalApiError(`Evaluation API returned HTTP ${httpStatus}.`, {
+    code: `EVAL_API_HTTP_${httpStatus}`,
+    httpStatus,
+    hint: httpStatus >= 500 ? "The server response was suppressed. Check the evaluation platform logs; the CLI did not retry." : void 0
+  });
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function logEvalRequest(method, url, status) {
+  logger.info(`EVAL ${method} ${redactEvalLogUrl(url)} status=${status}`);
+}
+function redactEvalLogUrl(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return "[invalid evaluation URL]";
+  }
+}
+
+export {
+  resolveEvaluationHost,
+  EvalApiError,
+  evalRequest,
+  evalDownloadFile
+};

package/dist/{chunk-WNGFSIOB.js → chunk-ZW4VMY5H.js}

@@ -48,8 +48,97 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/core/logger.ts
+// src/core/url-utils.ts
+function normalizeUrl(url) {
+  if (!url) return url;
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+
+// src/core/external-cli-token.ts
 import fs from "fs";
+var ExternalCliTokenError = class extends Error {
+  constructor(message, code = "EXTERNAL_CLI_TOKEN_INVALID") {
+    super(message);
+    this.code = code;
+    this.name = "ExternalCliTokenError";
+  }
+  code;
+  hint = "Set AE_CLI_TOKEN with AE_CLI_TOKEN_HOST, or use a JSON CLI token file containing url and token. Remove external token settings to use stored accounts.";
+};
+var explicitTokenFile;
+var diagnosticSecrets = /* @__PURE__ */ new Set();
+function setExternalCliTokenFile(file) {
+  explicitTokenFile = file;
+}
+function normalizedHost(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new ExternalCliTokenError("The external CLI token requires a host URL.");
+  }
+  try {
+    const url = new URL(value);
+    if (!["http:", "https:"].includes(url.protocol) || !url.hostname || url.username || url.password || url.search || url.hash || /\s/.test(value)) throw new Error();
+    return normalizeUrl(url.toString());
+  } catch {
+    throw new ExternalCliTokenError("The external CLI token host must be an HTTP(S) URL without credentials, query, or fragment.");
+  }
+}
+function credential(url, value, source) {
+  if (typeof value !== "string" || !/^cli_[!-~]+$/.test(value.trim())) {
+    throw new ExternalCliTokenError("The external CLI token must be a non-empty ASCII cli_ token without whitespace.");
+  }
+  return { url: normalizedHost(url), token: value.trim(), source };
+}
+function readExternalCliToken(hostOverride) {
+  let entry;
+  const file = explicitTokenFile ?? (process.env.AE_CLI_TOKEN === void 0 ? process.env.AE_CLI_TOKEN_FILE : void 0);
+  if (file !== void 0) {
+    if (!file.trim()) throw new ExternalCliTokenError("The external CLI token file path is empty.");
+    let data;
+    try {
+      const stat = fs.statSync(file);
+      if (!stat.isFile() || stat.size > 64 * 1024) throw new Error();
+      data = JSON.parse(fs.readFileSync(file, "utf8"));
+    } catch {
+      throw new ExternalCliTokenError("The external CLI token file must be a readable JSON file no larger than 64 KiB.");
+    }
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new ExternalCliTokenError("The external CLI token file must contain an object with url and token.");
+    }
+    entry = credential(data.url, data.token ?? data["cli-token"], "file-cli-token");
+  } else if (process.env.AE_CLI_TOKEN !== void 0) {
+    entry = credential(process.env.AE_CLI_TOKEN_HOST, process.env.AE_CLI_TOKEN, "environment-cli-token");
+  } else if (process.env.AE_CLI_TOKEN_HOST !== void 0) {
+    throw new ExternalCliTokenError("AE_CLI_TOKEN_HOST requires AE_CLI_TOKEN.");
+  }
+  if (entry && hostOverride && normalizedHost(hostOverride) !== entry.url) {
+    throw new ExternalCliTokenError("The selected host does not match the external CLI token host.");
+  }
+  if (entry) diagnosticSecrets.add(entry.token);
+  return entry;
+}
+function externalCliTokenRequestOptions(destination) {
+  const external = readExternalCliToken();
+  if (!external) return {};
+  if (new URL(destination).origin !== new URL(external.url).origin) {
+    throw new ExternalCliTokenError("The request destination does not match the external CLI token host.");
+  }
+  return { redirect: "error" };
+}
+function redactExternalCliToken(value) {
+  try {
+    readExternalCliToken();
+  } catch {
+  }
+  const forms = [...diagnosticSecrets].flatMap((token) => [token, JSON.stringify(token).slice(1, -1), encodeURIComponent(token)]);
+  for (const form of [...new Set(forms)].sort((a, b) => b.length - a.length)) value = value.split(form).join("[REDACTED]");
+  return value;
+}
+
+// src/core/logger.ts
+import fs2 from "fs";
 import path from "path";
 var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
 var Logger = class {
@@ -68,8 +157,8 @@ var Logger = class {
     return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
   }
   ensureDir() {
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
+    if (!fs2.existsSync(this.logDir)) {
+      fs2.mkdirSync(this.logDir, { recursive: true });
     }
   }
   filePath(level) {
@@ -84,10 +173,10 @@ var Logger = class {
    */
   write(level, message) {
     const ts = this.timestamp();
-    const line = `[${ts}] ${message}
+    const line = `[${ts}] ${redactExternalCliToken(message)}
 `;
     try {
-      fs.appendFileSync(this.filePath(level), line);
+      fs2.appendFileSync(this.filePath(level), line);
     } catch {
     }
   }
@@ -133,16 +222,18 @@ var logger = new Logger();
 
 // src/core/errors.ts
 var PermissionError = class extends Error {
-  constructor(message, code, hint, details) {
+  constructor(message, code, hint, details, meta) {
     super(message);
     this.code = code;
     this.hint = hint;
     this.details = details;
+    this.meta = meta;
     this.name = "PermissionError";
   }
   code;
   hint;
   details;
+  meta;
 };
 function isApiErrorType(value) {
   return value === "auth" || value === "permission" || value === "validation" || value === "not_found" || value === "api";
@@ -219,6 +310,12 @@ export {
   __export,
   __toESM,
   __toCommonJS,
+  normalizeUrl,
+  ExternalCliTokenError,
+  setExternalCliTokenFile,
+  readExternalCliToken,
+  externalCliTokenRequestOptions,
+  redactExternalCliToken,
   logger,
   PermissionError,
   isApiErrorType,

package/dist/{community-report-client-PEERQCX2.js → community-report-client-S2K3A3Q6.js}

@@ -2,7 +2,7 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   CommunityReportError,
   logger
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // src/core/community-report-client.ts
 var DEFAULT_TIMEOUT_MS = 3e4;

package/dist/{config-FF6YVJKI.js → config-ASSAAIOI.js}

@@ -1,33 +1,34 @@
 import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
-import {
-  AE_TRIAL_URL,
-  missingAeHostHint
-} from "./chunk-6ZIQV5GW.js";
 import {
   MultiselectCancelled,
   promptSingleSelect
 } from "./chunk-7K24F7T2.js";
+import {
+  AE_TRIAL_URL,
+  missingAeHostHint
+} from "./chunk-6ZIQV5GW.js";
 import {
   fetchCliConfig,
   printError,
   printOutput,
   resolveKbAutoDiscoveryFeature
-} from "./chunk-KFNMQTZI.js";
+} from "./chunk-ELCR235M.js";
 import {
   peekCliToken
-} from "./chunk-GIK6EDUG.js";
+} from "./chunk-P7KL7IOH.js";
 import {
   addHost,
   getActiveHost,
   listHosts,
   loadConfig,
-  normalizeUrl,
   removeHost,
   resolveHostSelector,
   setActiveHost,
   updateHostLabel
-} from "./chunk-UQ77JXYH.js";
-import "./chunk-WNGFSIOB.js";
+} from "./chunk-LMCYSVVA.js";
+import {
+  normalizeUrl
+} from "./chunk-ZW4VMY5H.js";
 
 // src/commands/config.ts
 import * as readline2 from "readline";

package/dist/{context-YAE3QXP3.js → context-6RWLVOM5.js}

@@ -2,15 +2,15 @@ import { createRequire as __createRequire } from 'node:module'; const require =
 import {
   TeAgentApiError,
   getFromMainApp
-} from "./chunk-PLE722AJ.js";
+} from "./chunk-2UWS5CUP.js";
 import "./chunk-Y74WTIKJ.js";
-import "./chunk-GIK6EDUG.js";
+import "./chunk-P7KL7IOH.js";
 import {
   safeJsonParse
-} from "./chunk-UQ77JXYH.js";
+} from "./chunk-LMCYSVVA.js";
 import {
   CliValidationError
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // src/core/current-page-context-client.ts
 async function readCurrentPageContext(path) {

package/dist/{data-integration-HESZET7E.js → data-integration-EXSUPUDZ.js}

@@ -8,20 +8,20 @@ import {
   utils,
   validateAndFix,
   validateDraft
-} from "./chunk-5XJYLEVC.js";
-import "./chunk-CT7QDJS6.js";
+} from "./chunk-KHS64JZQ.js";
+import "./chunk-2IYIYSUO.js";
 import {
   require_archiver
-} from "./chunk-AP7YP2NX.js";
-import "./chunk-S6M42KND.js";
+} from "./chunk-QSAR3GHY.js";
+import "./chunk-T44M3PLZ.js";
 import {
   getConfigDir
-} from "./chunk-UQ77JXYH.js";
+} from "./chunk-LMCYSVVA.js";
 import {
   CliValidationError,
   LocalDataUploadError,
   __toESM
-} from "./chunk-WNGFSIOB.js";
+} from "./chunk-ZW4VMY5H.js";
 
 // src/commands/data-integration/inspect.ts
 import { basename as basename3 } from "path";