@thinkingai/ae-cli 6.0.22 → 6.0.24

package/dist/{auth-RDN6D5HU.js → auth-A2XXG5K4.js}

@@ -1,26 +1,24 @@
 import {
   printError,
   printOutput
-} from "./chunk-YACCPUNQ.js";
+} from "./chunk-ONOA6DYB.js";
 import {
   clearCliToken,
   mintCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-OCQPQYHZ.js";
 import {
   clear,
-  clearToken,
-  getAuthStatus,
   load,
   resolveHost,
   save
-} from "./chunk-U6QPKCN3.js";
+} from "./chunk-PFJFZVCK.js";
 import {
   getFallbackCliToken,
   loadConfig,
   logger,
   removeHost,
   saveConfig
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/device-auth.ts
 import { execFileSync } from "child_process";
@@ -369,15 +367,14 @@ function registerAuth(program) {
           authenticated: true,
           host,
           source: "sandbox-cli-token",
-          hasCliToken: true
+          hasCliToken: true,
+          note: "sandbox-provisioned cli-token.json; no user access token in secure-store"
         },
         program.opts().format || "json"
       );
       return;
     }
-    const tokenStatus = getAuthStatus(host);
-    const authenticated = tokenStatus.authenticated;
-    printOutput({ authenticated, host, source: tokenStatus.source ?? "none" }, program.opts().format || "json");
+    printOutput({ authenticated: false, host, source: "none" }, program.opts().format || "json");
   });
   auth.command("logout").description("Clear stored credentials (access token, CLI token, and host config) for a host (--host or active host)").option("--host <url>", HOST_OPTION_DESC).action((opts) => {
     const host = resolveAuthHost(program, opts);
@@ -386,7 +383,6 @@ function registerAuth(program) {
       process.exit(1);
     }
     clearCliToken(host);
-    clearToken(host);
     clear(host);
     removeHost(host);
     process.stderr.write(`[ae-cli] Credentials and config cleared for ${host}

package/dist/auth-IDPKDFSY.js

@@ -0,0 +1,13 @@
+import {
+  getToken,
+  invalidateAccessTokenForRetry,
+  resolveHost,
+  validateToken
+} from "./chunk-PFJFZVCK.js";
+import "./chunk-65DKFJZB.js";
+export {
+  getToken,
+  invalidateAccessTokenForRetry,
+  resolveHost,
+  validateToken
+};

package/dist/{chunk-4EUZRJPO.js → chunk-2OW2RENH.js}

@@ -4,30 +4,33 @@ import {
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-OCQPQYHZ.js";
 import {
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";
 import { basename } from "path";
 var CapabilityGatewayError = class extends Error {
-  constructor(message, code, httpStatus) {
+  constructor(message, code, httpStatus, hint) {
     super(message);
     this.code = code;
     this.httpStatus = httpStatus;
+    this.hint = hint;
     this.name = "CapabilityGatewayError";
   }
   code;
   httpStatus;
+  hint;
 };
 function buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams = {}) {
   const base = host.replace(/\/+$/, "");
   const cleanDomain = domain.replace(/^\/+|\/+$/g, "");
   const cleanPath = pathAfterV1.replace(/^\/+|\/+$/g, "");
-  const url = new URL(`${base}/api/cli/${cleanDomain}/v1/${cleanPath}`);
+  const gatewayPrefix = cleanDomain === "" ? "/api/cli/v1" : `/api/cli/${cleanDomain}/v1`;
+  const url = new URL(`${base}${gatewayPrefix}/${cleanPath}`);
   for (const [key, value] of Object.entries(queryParams)) {
     if (value !== void 0 && value !== null) {
       url.searchParams.set(key, String(value));
@@ -62,11 +65,37 @@ function unwrapCapabilityEnvelope(body) {
       return body.data;
     }
     const err = body.error ?? {};
-    const message = err.message || err.code || "Capability gateway request failed";
-    throw new CapabilityGatewayError(message, err.code, err.http_status ?? err.httpStatus);
+    const code = nonEmptyString(err.code);
+    const message = nonEmptyString(err.message) ?? code ?? "Capability gateway request failed";
+    const hint = nonEmptyString(err.hint);
+    throw new CapabilityGatewayError(message, code, err.http_status ?? err.httpStatus, hint);
   }
   return body;
 }
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function buildCapabilityHttpError(resp, body) {
+  const fallback = `Capability gateway HTTP error: ${resp.status} ${resp.statusText}`.trim();
+  if (body && typeof body === "object") {
+    const err = body.error ?? body.data?.error ?? body;
+    const code = nonEmptyString(err.code) ?? nonEmptyString(err.errorCode) ?? nonEmptyString(body.code);
+    const message = nonEmptyString(err.message) ?? nonEmptyString(body.message);
+    const hint = nonEmptyString(err.hint) ?? nonEmptyString(body.hint);
+    const details = [code, message, hint ? `Hint: ${hint}` : void 0].filter(Boolean);
+    if (details.length > 0) {
+      return new CapabilityGatewayError(message ?? fallback, code, resp.status, hint);
+    }
+  }
+  if (typeof body === "string" && body.trim()) {
+    return new CapabilityGatewayError(`${fallback}: ${body.slice(0, 500)}`, void 0, resp.status);
+  }
+  return new CapabilityGatewayError(fallback, void 0, resp.status);
+}
+async function throwCapabilityHttpError(resp) {
+  const body = parseCapabilityResponse(await resp.text());
+  throw buildCapabilityHttpError(resp, body);
+}
 async function requestOnce(url, method, token, body) {
   const headers = {
     "cli-token": token,
@@ -107,10 +136,10 @@ async function callGateway(host, domain, pathAfterV1, method, body) {
       throw new PermissionError(await permissionMessage(resp));
     }
     if (!resp.ok) {
-      throw new Error(`Capability gateway HTTP error: ${resp.status} ${resp.statusText}`);
+      await throwCapabilityHttpError(resp);
     }
   } else if (!resp.ok) {
-    throw new Error(`Capability gateway HTTP error: ${resp.status} ${resp.statusText}`);
+    await throwCapabilityHttpError(resp);
   }
   return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
 }
@@ -147,15 +176,16 @@ async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, fil
       throw new PermissionError(await permissionMessage(resp));
     }
     if (!resp.ok) {
-      throw new Error(`Capability gateway HTTP error: ${resp.status} ${resp.statusText}`);
+      await throwCapabilityHttpError(resp);
     }
   } else if (!resp.ok) {
-    throw new Error(`Capability gateway HTTP error: ${resp.status} ${resp.statusText}`);
+    await throwCapabilityHttpError(resp);
   }
   return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
 }
 
 export {
+  CapabilityGatewayError,
   buildCapabilityGatewayUrl,
   executeCapability,
   uploadInputFile,

package/dist/{chunk-H52CSLJW.js → chunk-4FQ36OGO.js}

@@ -1,7 +1,7 @@
 import {
   getActiveHost,
   getSandboxRuntimeRoot
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/te-agent-credentials.ts
 import { readFileSync } from "fs";
@@ -147,8 +147,8 @@ async function signRequest(method, path, rawBody) {
       rawBody
     };
   }
-  const { getToken } = await import("./auth-I2G7OAU2.js");
-  const { getCliToken } = await import("./cli-token-6AGEDJF4.js");
+  const { getToken } = await import("./auth-IDPKDFSY.js");
+  const { getCliToken } = await import("./cli-token-OZXHC3U2.js");
   const baseUrl = sandboxCred?.url || teClaudeBaseFromActiveHost();
   const hostForToken = getActiveHost() || baseUrl;
   if (!baseUrl) {
@@ -293,7 +293,7 @@ async function uploadToMainApp(path, formData) {
       "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
     };
   } else {
-    const { getToken } = await import("./auth-I2G7OAU2.js");
+    const { getToken } = await import("./auth-IDPKDFSY.js");
     baseUrl = (sandboxCred?.url || teClaudeBaseFromActiveHost() || "").replace(/\/$/, "");
     if (!baseUrl) {
       throw new TeAgentCredentialsError(

package/dist/chunk-AKORWVHJ.js

@@ -0,0 +1,59 @@
+import {
+  buildCapabilityGatewayUrl,
+  executeCapability
+} from "./chunk-V5R5UIRM.js";
+
+// src/core/capability-routing.ts
+var cliServiceRoutes = /* @__PURE__ */ new Map();
+function registerCapabilityGatewayRoute(cliService, route) {
+  cliServiceRoutes.set(cliService, route);
+}
+function resolveGatewayDomain(cliService, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const route = cliServiceRoutes.get(cliService);
+  if (!route) {
+    throw new Error(
+      `Capability gateway route not registered for CLI service '${cliService}'. Call registerCapabilityGatewayRoute() in commands/${cliService}/index.ts.`
+    );
+  }
+  return route.gatewayDomain;
+}
+
+// src/core/capability-command.ts
+function createCapabilityCommand(config) {
+  return {
+    service: config.cliService,
+    resource: config.resource,
+    command: config.command,
+    description: config.description,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate,
+    dryRun: (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return {
+        method: "POST",
+        url: buildCapabilityGatewayUrl(
+          ctx.host(),
+          gatewayDomain,
+          `capabilities/${config.capabilityId}/dry-run`
+        ),
+        body: { input }
+      };
+    },
+    execute: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return executeCapability(ctx.host(), gatewayDomain, config.capabilityId, input);
+    }
+  };
+}
+
+export {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain,
+  createCapabilityCommand
+};

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

@@ -1,13 +1,13 @@
 import {
   SecureStoreAuthError,
-  clearToken,
   getToken,
+  invalidateAccessTokenForRetry,
   resolveHost
-} from "./chunk-U6QPKCN3.js";
+} from "./chunk-PFJFZVCK.js";
 import {
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/client.ts
 import WebSocket from "ws";
@@ -46,7 +46,7 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
   logger.api(method, url, resp.status, body, data);
   if (resp.status === 401) {
     if (retry) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       return request(method, modulePath, params, body, false, resolvedHost);
     }
     throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
@@ -56,7 +56,7 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
     throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
-    clearToken(resolvedHost);
+    invalidateAccessTokenForRetry(resolvedHost);
     return request(method, modulePath, params, body, false, resolvedHost);
   }
   if (data.return_code !== 0 && data.return_code !== void 0) {
@@ -89,7 +89,7 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
   logger.api("POST", url, resp.status, { upload: true }, data);
   if (resp.status === 401) {
     if (retry) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       return uploadRequest(modulePath, form, params, false, resolvedHost);
     }
     throw new SecureStoreAuthError(`Session expired or unauthorized for ${resolvedHost}. Please run: ae-cli auth login`);
@@ -99,7 +99,7 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
     throw new Error(m);
   }
   if (data.return_code === -1001 && retry) {
-    clearToken(resolvedHost);
+    invalidateAccessTokenForRetry(resolvedHost);
     return uploadRequest(modulePath, form, params, false, resolvedHost);
   }
   if (data.return_code !== 0 && data.return_code !== void 0) {
@@ -162,7 +162,7 @@ async function wsQuery(projectId, requestId, qp, eventModel, options = {}, hostU
   } catch (err) {
     const msg = err.message || "";
     if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
-      clearToken(resolvedHost);
+      invalidateAccessTokenForRetry(resolvedHost);
       const newToken = await getToken(resolvedHost);
       return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
     }

package/dist/chunk-FIT4CFIN.js

@@ -0,0 +1,59 @@
+import {
+  buildCapabilityGatewayUrl,
+  executeCapability
+} from "./chunk-2OW2RENH.js";
+
+// src/core/capability-routing.ts
+var cliServiceRoutes = /* @__PURE__ */ new Map();
+function registerCapabilityGatewayRoute(cliService, route) {
+  cliServiceRoutes.set(cliService, route);
+}
+function resolveGatewayDomain(cliService, override) {
+  if (override !== void 0) {
+    return override;
+  }
+  const route = cliServiceRoutes.get(cliService);
+  if (!route) {
+    throw new Error(
+      `Capability gateway route not registered for CLI service '${cliService}'. Call registerCapabilityGatewayRoute() in commands/${cliService}/index.ts.`
+    );
+  }
+  return route.gatewayDomain;
+}
+
+// src/core/capability-command.ts
+function createCapabilityCommand(config) {
+  return {
+    service: config.cliService,
+    resource: config.resource,
+    command: config.command,
+    description: config.description,
+    flags: config.flags,
+    risk: config.risk,
+    validate: config.validate,
+    dryRun: (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return {
+        method: "POST",
+        url: buildCapabilityGatewayUrl(
+          ctx.host(),
+          gatewayDomain,
+          `capabilities/${config.capabilityId}/dry-run`
+        ),
+        body: { input }
+      };
+    },
+    execute: async (ctx) => {
+      const gatewayDomain = resolveGatewayDomain(config.cliService, config.gatewayDomain);
+      const input = config.buildInput(ctx);
+      return executeCapability(ctx.host(), gatewayDomain, config.capabilityId, input);
+    }
+  };
+}
+
+export {
+  registerCapabilityGatewayRoute,
+  resolveGatewayDomain,
+  createCapabilityCommand
+};

package/dist/{chunk-2W7HULUD.js → chunk-IDXW6MEJ.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-NOO24N7W.js";
 import {
   getCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-OCQPQYHZ.js";
 import {
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/mcp-access.ts
 function buildUrl(host, path, params = {}) {

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

@@ -1,18 +1,18 @@
 import {
   getAnalysisMappingPathForClusterMode
-} from "./chunk-XE2PI5DS.js";
+} from "./chunk-WXBCP6SD.js";
 import {
   PermissionError
 } from "./chunk-NOO24N7W.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-OCQPQYHZ.js";
 import {
   getActiveHost,
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/mcp.ts
 async function permissionMessage(resp) {

package/dist/chunk-NXJP4CES.js

@@ -0,0 +1,209 @@
+import {
+  getAnalysisMappingPathForClusterMode
+} from "./chunk-WXBCP6SD.js";
+import {
+  PermissionError
+} from "./chunk-NOO24N7W.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-OCQPQYHZ.js";
+import {
+  getActiveHost,
+  logger,
+  safeJsonParse
+} from "./chunk-65DKFJZB.js";
+
+// src/core/mcp.ts
+async function permissionMessage(resp) {
+  const text = await resp.text().catch(() => "");
+  try {
+    const d = safeJsonParse(text);
+    const msg = d && (d.error?.message || (typeof d.error === "string" ? d.error : void 0) || d.message);
+    if (msg && typeof msg === "string") return msg;
+  } catch {
+  }
+  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();
+registerMcpMapping("analysis", {
+  componentName: "analysis",
+  mappingPath: "analysis"
+});
+registerMcpMapping("te_analysis_extend", {
+  componentName: "analysis",
+  mappingPath: "analysis-extend"
+});
+function registerMcpMapping(serviceName, mapping) {
+  serviceMappingMap.set(serviceName, mapping);
+}
+function registerMcpMappings(mappings) {
+  for (const [serviceName, mapping] of Object.entries(mappings)) {
+    serviceMappingMap.set(serviceName, mapping);
+  }
+}
+function getMcpMapping(serviceName) {
+  const mapping = serviceMappingMap.get(serviceName);
+  if (!mapping) {
+    throw new Error(`MCP mapping not found for service: '${serviceName}'. Please register it using registerMcpMapping() first.`);
+  }
+  if (serviceName === "analysis") {
+    return { ...mapping, mappingPath: getAnalysisMappingPathForClusterMode() };
+  }
+  return mapping;
+}
+function buildMcpUrl(host, serviceName) {
+  const mapping = getMcpMapping(serviceName);
+  const base = host.replace(/\/+$/, "");
+  return `${base}/mcp/${mapping.componentName}/http/${mapping.mappingPath}`;
+}
+function resolveMcpUrl(mcpUrlOverride, host, serviceName) {
+  if (mcpUrlOverride) {
+    return mcpUrlOverride;
+  }
+  return buildMcpUrl(host, serviceName);
+}
+var requestIdCounter = 1;
+function genRequestId() {
+  return requestIdCounter++;
+}
+function buildAuthHeaders(cliToken) {
+  return {
+    "cli-token": cliToken
+  };
+}
+async function mcpRequest(url, method, params = {}, hostOverride) {
+  const hostUrl = hostOverride || getActiveHost();
+  const token = await getCliToken(hostUrl);
+  const requestId = genRequestId();
+  const paramsWithMeta = {
+    ...params,
+    _meta: { progressToken: requestId }
+  };
+  const body = {
+    jsonrpc: JSONRPC_VERSION,
+    id: requestId,
+    method,
+    params: paramsWithMeta
+  };
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json, text/event-stream",
+    "mcp-protocol-version": MCP_PROTOCOL_VERSION,
+    "X-Source": "ae-cli",
+    ...buildAuthHeaders(token)
+  };
+  const resp = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!resp.ok) {
+    let permissionMsg;
+    if (resp.status === 403) {
+      permissionMsg = await permissionMessage(resp);
+      if (!isInvalidCliTokenMessage(permissionMsg)) {
+        throw new PermissionError(permissionMsg);
+      }
+    }
+    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}
+`);
+      Object.assign(headers, buildAuthHeaders(newToken));
+      const retryResp = await fetch(url, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body)
+      });
+      if (retryResp.status === 403) {
+        throw new PermissionError(await permissionMessage(retryResp));
+      }
+      if (!retryResp.ok) {
+        throw new Error(`MCP HTTP error: ${retryResp.status} ${retryResp.statusText}`);
+      }
+      const retryData = safeJsonParse(await retryResp.text());
+      if (retryData.error) {
+        throw new Error(`MCP error: ${retryData.error.message || JSON.stringify(retryData.error)}`);
+      }
+      return retryData.result;
+    }
+    throw new Error(`MCP HTTP error: ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(await resp.text());
+  if (data.error) {
+    throw new Error(`MCP error: ${data.error.message || JSON.stringify(data.error)}`);
+  }
+  return data.result;
+}
+async function callMcpTool(url, toolName, args = {}, hostOverride) {
+  const params = {
+    name: toolName,
+    arguments: args
+  };
+  logger.info(`MCP tool call: ${toolName}`);
+  const result = await mcpRequest(url, "tools/call", params, hostOverride);
+  if (result.isError) {
+    logger.warn(`MCP tool call failed: ${toolName}`);
+  }
+  return {
+    content: result.content.map((item) => {
+      if (item.type === "text") {
+        return { type: "text", text: item.text };
+      } else if (item.type === "image") {
+        return { type: "image", data: item.data, mimeType: item.mimeType };
+      } else {
+        return { type: "resource", ...item };
+      }
+    }),
+    isError: result.isError
+  };
+}
+function parseMcpResult(result) {
+  if (result.content.length > 0 && result.content[0].type === "text") {
+    const text = result.content[0].text || "";
+    let parsed;
+    try {
+      parsed = safeJsonParse(text);
+    } catch {
+      return text;
+    }
+    const errMsg = mcpResultErrorMessage(parsed);
+    if (errMsg !== null) {
+      if (/no_auth|auth_error|permission|forbidden|unauthor|\u65e0\u6743/i.test(errMsg)) {
+        throw new PermissionError(errMsg);
+      }
+      throw new Error(errMsg);
+    }
+    return parsed;
+  }
+  return result;
+}
+function mcpResultErrorMessage(parsed) {
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null;
+  if (parsed.success === true || parsed.ok === true) return null;
+  const e = parsed.error;
+  if (typeof e === "string" && e.trim()) return e;
+  if (e && typeof e === "object") {
+    const msg = typeof e.message === "string" && e.message || void 0;
+    const code = typeof e.code === "string" && e.code || void 0;
+    if (msg && code) return `${code}: ${msg}`;
+    if (msg || code) return msg || code;
+  }
+  return null;
+}
+
+export {
+  registerMcpMappings,
+  resolveMcpUrl,
+  callMcpTool,
+  parseMcpResult
+};

package/dist/{chunk-FPE5LGVU.js → chunk-OCQPQYHZ.js}

@@ -3,14 +3,14 @@ import {
   load,
   loadCliToken,
   save
-} from "./chunk-U6QPKCN3.js";
+} from "./chunk-PFJFZVCK.js";
 import {
   getActiveHost,
   getFallbackCliToken,
   listHosts,
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/core/cli-token.ts
 var CLI_TOKEN_GENERATE_PATH = "/v1/ta/cli/token/generate";

package/dist/{chunk-YACCPUNQ.js → chunk-ONOA6DYB.js}

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