@thinkingai/ae-cli 6.0.18 → 6.0.22

package/dist/{chunk-DMMEPCST.js → chunk-5FBLRSMU.js}

@@ -1,19 +1,18 @@
 import {
   getAnalysisMappingPathForClusterMode
-} from "./chunk-PN3OS34E.js";
+} from "./chunk-XE2PI5DS.js";
 import {
   PermissionError
 } from "./chunk-NOO24N7W.js";
 import {
-  getToken,
-  loadMcpToken
-} from "./chunk-RSHMZ3LG.js";
+  clearCliToken,
+  getCliToken
+} from "./chunk-FPE5LGVU.js";
 import {
   getActiveHost,
-  getFallbackMcpToken,
   logger,
   safeJsonParse
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/core/mcp.ts
 async function permissionMessage(resp) {
@@ -26,6 +25,9 @@ async function permissionMessage(resp) {
   }
   return "Permission denied for this resource (HTTP 403)";
 }
+function isInvalidCliTokenMessage(message) {
+  return /\b(cli[-_\s]?token|token)\b.*\binvalid\b/i.test(message) || /\binvalid\b.*\b(cli[-_\s]?token|token)\b/i.test(message);
+}
 var MCP_PROTOCOL_VERSION = "2025-11-25";
 var JSONRPC_VERSION = "2.0";
 var serviceMappingMap = /* @__PURE__ */ new Map();
@@ -70,104 +72,14 @@ var requestIdCounter = 1;
 function genRequestId() {
   return requestIdCounter++;
 }
-var MCP_TOKEN_GENERATE_PATH = "/v1/ta/mcp/token/generate";
-var _mcpTokenCache = /* @__PURE__ */ new Map();
-async function generateMcpToken(hostUrl) {
-  const teToken = await getToken(hostUrl);
-  const base = hostUrl.replace(/\/+$/, "");
-  const url = `${base}${MCP_TOKEN_GENERATE_PATH}`;
-  const resp = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Authorization": `bearer ${teToken}`
-    }
-  });
-  if (!resp.ok) {
-    throw new Error(`MCP token generate HTTP error: ${resp.status} ${resp.statusText}`);
-  }
-  const data = safeJsonParse(await resp.text());
-  if (data.return_code !== 0) {
-    throw new Error(`MCP token generate error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
-  }
-  const mcpToken = data.data?.userSecret;
-  if (!mcpToken) {
-    throw new Error("MCP token generate error: empty userSecret in response");
-  }
-  return mcpToken;
-}
-async function getMcpToken(hostOverride) {
-  const hostUrl = hostOverride || getActiveHost();
-  const cached = _mcpTokenCache.get(hostUrl);
-  if (cached) {
-    return cached;
-  }
-  const storedToken = loadMcpToken(hostUrl);
-  if (storedToken) {
-    _mcpTokenCache.set(hostUrl, storedToken);
-    logger.info(`Using persisted MCP token (secure-store) for ${hostUrl}`);
-    return storedToken;
-  }
-  const fallbackToken = getFallbackMcpToken(hostUrl);
-  if (fallbackToken) {
-    _mcpTokenCache.set(hostUrl, fallbackToken);
-    logger.info(`Using sandbox-provisioned MCP token (fallback file) for ${hostUrl}`);
-    return fallbackToken;
-  }
-  logger.info(`Generating MCP token for ${hostUrl}`);
-  const mcpToken = await generateMcpToken(hostUrl);
-  _mcpTokenCache.set(hostUrl, mcpToken);
-  logger.info(`MCP token generated and in-process cached for ${hostUrl}`);
-  return mcpToken;
-}
-function clearMcpToken(hostUrl) {
-  if (hostUrl) {
-    _mcpTokenCache.delete(hostUrl);
-  } else {
-    _mcpTokenCache.clear();
-  }
-}
-function setMcpTokenManual(token, hostUrl) {
-  _mcpTokenCache.set(hostUrl, token);
-  logger.info(`MCP token manually set (in-process) for ${hostUrl}`);
-}
-async function validateMcpToken(token, hostUrl) {
-  const mapping = getMcpMapping("analysis");
-  const base = hostUrl.replace(/\/+$/, "");
-  const url = `${base}/mcp/${mapping.componentName}/http/${mapping.mappingPath}`;
-  const requestId = 1;
-  const body = {
-    jsonrpc: JSONRPC_VERSION,
-    id: requestId,
-    method: "tools/list",
-    params: { _meta: { progressToken: requestId } }
-  };
-  const headers = {
-    "Content-Type": "application/json",
-    "Accept": "application/json, text/event-stream",
-    "mcp-protocol-version": MCP_PROTOCOL_VERSION,
-    "mcp-token": token
+function buildAuthHeaders(cliToken) {
+  return {
+    "cli-token": cliToken
   };
-  try {
-    const resp = await fetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(body)
-    });
-    if (!resp.ok) {
-      return false;
-    }
-    const data = safeJsonParse(await resp.text());
-    if (data.error) {
-      return false;
-    }
-    return data.result?.tools !== void 0;
-  } catch {
-    return false;
-  }
 }
 async function mcpRequest(url, method, params = {}, hostOverride) {
   const hostUrl = hostOverride || getActiveHost();
-  const token = await getMcpToken(hostUrl);
+  const token = await getCliToken(hostUrl);
   const requestId = genRequestId();
   const paramsWithMeta = {
     ...params,
@@ -183,7 +95,7 @@ async function mcpRequest(url, method, params = {}, hostOverride) {
     "Content-Type": "application/json",
     "Accept": "application/json, text/event-stream",
     "mcp-protocol-version": MCP_PROTOCOL_VERSION,
-    "mcp-token": token
+    ...buildAuthHeaders(token)
   };
   const resp = await fetch(url, {
     method: "POST",
@@ -191,19 +103,21 @@ async function mcpRequest(url, method, params = {}, hostOverride) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
+    let permissionMsg;
     if (resp.status === 403) {
-      throw new PermissionError(await permissionMessage(resp));
+      permissionMsg = await permissionMessage(resp);
+      if (!isInvalidCliTokenMessage(permissionMsg)) {
+        throw new PermissionError(permissionMsg);
+      }
     }
-    if (resp.status === 401) {
-      logger.warn(`MCP request failed (HTTP 401) for ${hostUrl}, re-minting token`);
-      _mcpTokenCache.delete(hostUrl);
-      const fallbackToken = getFallbackMcpToken(hostUrl);
-      const newToken = fallbackToken ?? await generateMcpToken(hostUrl);
-      _mcpTokenCache.set(hostUrl, newToken);
-      logger.info(`MCP token re-minted for ${hostUrl}`);
-      process.stderr.write(`[ae-cli] MCP token re-minted for ${hostUrl}
+    if (resp.status === 401 || resp.status === 403 && permissionMsg) {
+      logger.warn(`MCP request failed (${resp.status === 403 ? permissionMsg : "HTTP 401"}) for ${hostUrl}, refreshing CLI token`);
+      clearCliToken(hostUrl);
+      const newToken = await getCliToken(hostUrl);
+      logger.info(`CLI token refreshed for ${hostUrl}`);
+      process.stderr.write(`[ae-cli] CLI token refreshed for ${hostUrl}
 `);
-      headers["mcp-token"] = newToken;
+      Object.assign(headers, buildAuthHeaders(newToken));
       const retryResp = await fetch(url, {
         method: "POST",
         headers,
@@ -289,10 +203,6 @@ function mcpResultErrorMessage(parsed) {
 export {
   registerMcpMappings,
   resolveMcpUrl,
-  getMcpToken,
-  clearMcpToken,
-  setMcpTokenManual,
-  validateMcpToken,
   callMcpTool,
   parseMcpResult
 };

package/dist/{chunk-BJX3GXWC.js → chunk-E34XH4GW.js}

@@ -3,11 +3,11 @@ import {
   clearToken,
   getToken,
   resolveHost
-} from "./chunk-RSHMZ3LG.js";
+} from "./chunk-U6QPKCN3.js";
 import {
   logger,
   safeJsonParse
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/core/client.ts
 import WebSocket from "ws";

package/dist/chunk-FPE5LGVU.js

@@ -0,0 +1,105 @@
+import {
+  getToken,
+  load,
+  loadCliToken,
+  save
+} from "./chunk-U6QPKCN3.js";
+import {
+  getActiveHost,
+  getFallbackCliToken,
+  listHosts,
+  logger,
+  safeJsonParse
+} from "./chunk-WPXHCP4A.js";
+
+// src/core/cli-token.ts
+var CLI_TOKEN_GENERATE_PATH = "/v1/ta/cli/token/generate";
+var _cliTokenCache = /* @__PURE__ */ new Map();
+async function generateCliToken(hostUrl) {
+  const accessToken = await getToken(hostUrl);
+  const base = hostUrl.replace(/\/+$/, "");
+  const url = `${base}${CLI_TOKEN_GENERATE_PATH}`;
+  const resp = await fetch(url, {
+    method: "GET",
+    headers: {
+      "Authorization": `bearer ${accessToken}`
+    }
+  });
+  if (!resp.ok) {
+    throw new Error(`CLI token generate HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(await resp.text());
+  if (data.return_code !== 0) {
+    throw new Error(`CLI token generate error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  const cliToken = data.data?.userSecret;
+  if (!cliToken) {
+    throw new Error("CLI token generate error: empty userSecret in response");
+  }
+  return cliToken;
+}
+function persistCliTokenIfPossible(hostUrl, cliToken) {
+  const existing = load(hostUrl);
+  if (!existing) {
+    logger.info(`cli-token: no secure-store session for ${hostUrl}, keeping token in-process only`);
+    return;
+  }
+  save(hostUrl, { ...existing, cliToken });
+}
+function clearPersistedCliToken(hostUrl) {
+  const existing = load(hostUrl);
+  if (existing?.cliToken) {
+    save(hostUrl, { ...existing, cliToken: void 0 });
+  }
+}
+async function getCliToken(hostOverride) {
+  const hostUrl = hostOverride || getActiveHost();
+  const cached = _cliTokenCache.get(hostUrl);
+  if (cached) {
+    return cached;
+  }
+  const storedToken = loadCliToken(hostUrl);
+  if (storedToken) {
+    _cliTokenCache.set(hostUrl, storedToken);
+    logger.info(`Using persisted CLI token (secure-store) for ${hostUrl}`);
+    return storedToken;
+  }
+  const fallbackToken = getFallbackCliToken(hostUrl);
+  if (fallbackToken) {
+    _cliTokenCache.set(hostUrl, fallbackToken);
+    logger.info(`Using sandbox-provisioned CLI token (fallback file) for ${hostUrl}`);
+    return fallbackToken;
+  }
+  return mintCliToken(hostUrl);
+}
+async function mintCliToken(hostUrl) {
+  logger.info(`Generating CLI token for ${hostUrl}`);
+  const cliToken = await generateCliToken(hostUrl);
+  _cliTokenCache.set(hostUrl, cliToken);
+  persistCliTokenIfPossible(hostUrl, cliToken);
+  logger.info(`CLI token generated, cached, and persisted for ${hostUrl}`);
+  return cliToken;
+}
+function clearCliToken(hostUrl) {
+  if (hostUrl) {
+    _cliTokenCache.delete(hostUrl);
+    clearPersistedCliToken(hostUrl);
+    return;
+  }
+  _cliTokenCache.clear();
+  for (const { url } of listHosts()) {
+    clearPersistedCliToken(url);
+  }
+}
+function setCliTokenManual(token, hostUrl) {
+  _cliTokenCache.set(hostUrl, token);
+  persistCliTokenIfPossible(hostUrl, token);
+  logger.info(`CLI token set for ${hostUrl}`);
+}
+
+export {
+  getCliToken,
+  mintCliToken,
+  clearCliToken,
+  setCliTokenManual
+};

package/dist/{chunk-I5CRVM2S.js → chunk-H52CSLJW.js}

@@ -1,7 +1,7 @@
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
@@ -134,39 +134,66 @@ function teClaudeBaseFromActiveHost() {
 async function signRequest(method, path, rawBody) {
   const sandboxCred = tryLoadTeAgentSandboxCredentials();
   if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
-    const headers2 = {
+    const headers = {
       "X-Sandbox-Id": sandboxCred.sandboxId,
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
     if (method === "POST" || method === "PATCH") {
-      headers2["Content-Type"] = "application/json";
+      headers["Content-Type"] = "application/json";
     }
     return {
       url: `${sandboxCred.url.replace(/\/$/, "")}${path}`,
-      headers: headers2,
+      headers,
       rawBody
     };
   }
-  const { getToken } = await import("./auth-DYC2BGLM.js");
+  const { getToken } = await import("./auth-I2G7OAU2.js");
+  const { getCliToken } = await import("./cli-token-6AGEDJF4.js");
   const baseUrl = sandboxCred?.url || teClaudeBaseFromActiveHost();
+  const hostForToken = getActiveHost() || baseUrl;
   if (!baseUrl) {
     throw new TeAgentCredentialsError(
       "Cannot determine the te-claude service URL",
       "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
     );
   }
-  const accessToken = await getToken(getActiveHost() || baseUrl);
-  const headers = {
-    "Authorization": `bearer ${accessToken}`
-  };
-  if (method === "POST" || method === "PATCH") {
-    headers["Content-Type"] = "application/json";
+  const contentTypeHeader = method === "POST" || method === "PATCH" ? { "Content-Type": "application/json" } : {};
+  let accessToken = null;
+  try {
+    accessToken = await getToken(hostForToken);
+  } catch {
+    accessToken = null;
   }
-  return {
-    url: `${baseUrl.replace(/\/$/, "")}${path}`,
-    headers,
-    rawBody
-  };
+  if (accessToken) {
+    return {
+      url: `${baseUrl.replace(/\/$/, "")}${path}`,
+      headers: {
+        "Authorization": `bearer ${accessToken}`,
+        ...contentTypeHeader
+      },
+      rawBody
+    };
+  }
+  let cliToken = null;
+  try {
+    cliToken = await getCliToken(hostForToken);
+  } catch {
+    cliToken = null;
+  }
+  if (cliToken) {
+    return {
+      url: `${baseUrl.replace(/\/$/, "")}${path}`,
+      headers: {
+        "cli-token": cliToken,
+        ...contentTypeHeader
+      },
+      rawBody
+    };
+  }
+  throw new TeAgentCredentialsError(
+    "No te-claude credentials available",
+    "Run ae-cli auth login, or execute inside a te-agent sandbox"
+  );
 }
 async function parseResponse(response, defaultErrorPrefix) {
   const text = await response.text();
@@ -266,7 +293,7 @@ async function uploadToMainApp(path, formData) {
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
   } else {
-    const { getToken } = await import("./auth-DYC2BGLM.js");
+    const { getToken } = await import("./auth-I2G7OAU2.js");
     baseUrl = (sandboxCred?.url || teClaudeBaseFromActiveHost() || "").replace(/\/$/, "");
     if (!baseUrl) {
       throw new TeAgentCredentialsError(

package/dist/{chunk-RSHMZ3LG.js → chunk-U6QPKCN3.js}

@@ -4,7 +4,7 @@ import {
   logger,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/core/auth.ts
 import fs2 from "fs";
@@ -170,15 +170,15 @@ async function getValidAccessToken(host) {
   if (payload.refreshToken) {
     logger.info(`secure-store: access token past local expiry for ${host}, refreshing\u2026`);
     const refreshed = await doRefresh(host, payload.refreshToken);
-    save(host, { ...refreshed, mcpToken: payload.mcpToken });
+    save(host, { ...refreshed, cliToken: payload.cliToken });
     logger.info(`secure-store: token refreshed for ${host}`);
     return refreshed.accessToken;
   }
   logger.info(`secure-store: ${host} past static local expiry, no refresh token \u2014 returning stored token, server validates (lazy)`);
   return payload.accessToken;
 }
-function loadMcpToken(host) {
-  return load(host)?.mcpToken ?? null;
+function loadCliToken(host) {
+  return load(host)?.cliToken ?? null;
 }
 async function doRefresh(host, refreshToken) {
   const base = host.replace(/\/+$/, "");
@@ -345,13 +345,7 @@ function clearToken(hostUrl) {
   delete tokens[hostUrl];
   saveAllTokens(tokens);
 }
-function setTokenManual(token, hostUrl) {
-  saveToken(token, hostUrl);
-}
 function getAuthStatus(hostUrl) {
-  if (process.env.TE_TOKEN) {
-    return { authenticated: true, host: hostUrl, source: "env:TE_TOKEN" };
-  }
   const cached = loadToken(hostUrl);
   if (cached) {
     const ageMs = Date.now() - new Date(cached.updatedAt).getTime();
@@ -367,10 +361,6 @@ async function getToken(hostUrl) {
 Run: ae-cli config set-host <url>`
     );
   }
-  if (process.env.TE_TOKEN) {
-    logger.info("Using token from env:TE_TOKEN");
-    return process.env.TE_TOKEN;
-  }
   const cached = loadToken(hostUrl);
   if (cached && cached.token) {
     logger.info(`Using cached token for ${hostUrl}`);
@@ -389,10 +379,7 @@ Run: ae-cli config set-host <url>`
   }
   throw new Error(
     `Cannot obtain token for ${hostUrl}.
-Options:
-  1. ae-cli auth login   (device code flow, cross-platform)
-  2. ae-cli auth set-token <token>
-  3. export TE_TOKEN=<token>  (CI/headless)`
+Run: ae-cli auth login   (device code flow, cross-platform)`
   );
 }
 
@@ -400,14 +387,13 @@ export {
   save,
   load,
   clear,
-  loadMcpToken,
+  loadCliToken,
   SecureStoreAuthError,
   resolveHost,
   validateToken,
   loadToken,
   saveToken,
   clearToken,
-  setTokenManual,
   getAuthStatus,
   getToken
 };

package/dist/{chunk-6W4QOZAL.js → chunk-WPXHCP4A.js}

@@ -108,8 +108,8 @@ function getSandboxRuntimeRoot() {
 function getSandboxAeConfigDir() {
   return join(getSandboxRuntimeRoot(), ".ae-config");
 }
-function getSandboxMcpTokenFilePath() {
-  return join(getSandboxAeConfigDir(), "mcp-token.json");
+function getSandboxCliTokenFilePath() {
+  return join(getSandboxAeConfigDir(), "cli-token.json");
 }
 function getSandboxClusterInfoFilePath() {
   return join(getSandboxAeConfigDir(), "cluster-info.json");
@@ -118,22 +118,22 @@ function getSandboxClusterInfoFilePath() {
 // src/core/config.ts
 var CONFIG_DIR = path2.join(process.env.HOME || "", ".ae-cli");
 var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
-function sandboxMcpTokenCandidatePaths() {
-  const paths = [getSandboxMcpTokenFilePath()];
-  const homeFallback = path2.join(process.env.HOME || "", ".ae-config", "mcp-token.json");
+function sandboxCliTokenCandidatePaths() {
+  const paths = [getSandboxCliTokenFilePath()];
+  const homeFallback = path2.join(process.env.HOME || "", ".ae-config", "cli-token.json");
   if (!paths.includes(homeFallback)) {
     paths.push(homeFallback);
   }
   return paths;
 }
-function readSandboxMcpTokenEntry() {
-  for (const file of sandboxMcpTokenCandidatePaths()) {
+function readSandboxCliTokenEntry() {
+  for (const file of sandboxCliTokenCandidatePaths()) {
     if (!fs3.existsSync(file)) continue;
     try {
       const data = safeReadJsonFile(file);
       if (data && typeof data === "object" && !Array.isArray(data)) {
         const url = data.url;
-        const token = data["mcp-token"];
+        const token = data.token;
         if (url && token) {
           return { url, token };
         }
@@ -147,11 +147,11 @@ function ensureDir() {
   if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
 }
 function forceMigrateFromFallback() {
-  const entry = readSandboxMcpTokenEntry();
+  const entry = readSandboxCliTokenEntry();
   if (!entry) return null;
   return { [entry.url]: entry.token };
 }
-function getFallbackMcpToken(hostUrl) {
+function getFallbackCliToken(hostUrl) {
   const store = forceMigrateFromFallback();
   if (!store) return null;
   if (hostUrl && store[hostUrl]) return store[hostUrl];
@@ -197,9 +197,10 @@ function saveConfig(config) {
   logger.info(`Config saved: activeHost=${config.activeHost}, hosts=${Object.keys(config.hosts).length}`);
 }
 function getActiveHost() {
+  const sandboxHost = readSandboxCliTokenEntry()?.url;
+  if (sandboxHost) return sandboxHost;
   const config = loadConfig();
-  if (config.activeHost) return config.activeHost;
-  return readSandboxMcpTokenEntry()?.url ?? "";
+  return config.activeHost || "";
 }
 function setActiveHost(url) {
   const config = loadConfig();
@@ -233,6 +234,14 @@ function removeHost(url) {
   }
   saveConfig(config);
 }
+function listHosts() {
+  const config = loadConfig();
+  return Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+}
 function getConfigDir() {
   return CONFIG_DIR;
 }
@@ -243,12 +252,13 @@ export {
   safeReadJsonFile,
   getSandboxRuntimeRoot,
   getSandboxClusterInfoFilePath,
-  getFallbackMcpToken,
+  getFallbackCliToken,
   loadConfig,
   saveConfig,
   getActiveHost,
   setActiveHost,
   addHost,
   removeHost,
+  listHosts,
   getConfigDir
 };

package/dist/{chunk-PN3OS34E.js → chunk-XE2PI5DS.js}

@@ -2,7 +2,7 @@ import {
   getSandboxClusterInfoFilePath,
   logger,
   safeReadJsonFile
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/core/cluster-info.ts
 import fs from "fs";

package/dist/{chunk-2DUEAXV3.js → chunk-YACCPUNQ.js}

@@ -1,6 +1,6 @@
 import {
   logger
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/framework/output.ts
 import Table from "cli-table3";

package/dist/cli-token-6AGEDJF4.js

@@ -0,0 +1,14 @@
+import {
+  clearCliToken,
+  getCliToken,
+  mintCliToken,
+  setCliTokenManual
+} from "./chunk-FPE5LGVU.js";
+import "./chunk-U6QPKCN3.js";
+import "./chunk-WPXHCP4A.js";
+export {
+  clearCliToken,
+  getCliToken,
+  mintCliToken,
+  setCliTokenManual
+};

package/dist/{client-2UJ63MVQ.js → client-VTJMUZ4O.js}

@@ -7,9 +7,9 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-BJX3GXWC.js";
-import "./chunk-RSHMZ3LG.js";
-import "./chunk-6W4QOZAL.js";
+} from "./chunk-E34XH4GW.js";
+import "./chunk-U6QPKCN3.js";
+import "./chunk-WPXHCP4A.js";
 export {
   httpDelete,
   httpGet,

package/dist/{config-NCUGK6NS.js → config-2SDTLGOC.js}

@@ -1,19 +1,19 @@
 import {
   printError,
   printOutput
-} from "./chunk-2DUEAXV3.js";
+} from "./chunk-YACCPUNQ.js";
 import {
   GLOBAL_QUERY_CONFIG_KEY,
   getAnalysisMappingPathForClusterMode,
   getClusterInfoFilePath,
   isGlobalQueryModeEnabled,
   setGlobalQueryModeEnabled
-} from "./chunk-PN3OS34E.js";
+} from "./chunk-XE2PI5DS.js";
 import {
   addHost,
   loadConfig,
   setActiveHost
-} from "./chunk-6W4QOZAL.js";
+} from "./chunk-WPXHCP4A.js";
 
 // src/commands/config.ts
 function registerConfig(program) {