@thinkingai/ae-cli 6.0.22 → 6.0.24

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

@@ -2,13 +2,8 @@ import {
   getActiveHost,
   getConfigDir,
   logger,
-  safeJsonParse,
-  safeReadJsonFile
-} from "./chunk-WPXHCP4A.js";
-
-// src/core/auth.ts
-import fs2 from "fs";
-import path2 from "path";
+  safeJsonParse
+} from "./chunk-65DKFJZB.js";
 
 // src/core/secure-store.ts
 import crypto from "crypto";
@@ -236,22 +231,6 @@ var SecureStoreAuthError = class extends Error {
 };
 
 // src/core/auth.ts
-var TOKENS_FILE = path2.join(getConfigDir(), "tokens.json");
-var LEGACY_MCP_TOKENS_FILE = path2.join(getConfigDir(), "mcp-tokens.json");
-var LEGACY_DIR = path2.join(process.env.HOME || "", ".te-mcp");
-(function removeLegacyMcpTokens() {
-  try {
-    if (fs2.existsSync(LEGACY_MCP_TOKENS_FILE)) {
-      fs2.rmSync(LEGACY_MCP_TOKENS_FILE);
-      logger.info("auth: removed legacy mcp-tokens.json (plaintext MCP token file)");
-    }
-  } catch {
-  }
-})();
-function ensureDir() {
-  const dir = getConfigDir();
-  if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true });
-}
 function resolveHost(hostOverride) {
   if (hostOverride) return hostOverride;
   return getActiveHost();
@@ -270,89 +249,11 @@ async function validateToken(token, hostUrl) {
     return false;
   }
 }
-function loadAllTokens() {
-  try {
-    const legacyTokens = path2.join(LEGACY_DIR, "tokens.json");
-    if (fs2.existsSync(legacyTokens) && !fs2.existsSync(TOKENS_FILE)) {
-      const data = safeReadJsonFile(legacyTokens);
-      const migrated = {};
-      for (const [key, val] of Object.entries(data)) {
-        const url = key.startsWith("http") ? key : `https://${key}`;
-        migrated[url] = val;
-      }
-      ensureDir();
-      fs2.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
-      return migrated;
-    }
-    if (fs2.existsSync(TOKENS_FILE)) {
-      const data = safeReadJsonFile(TOKENS_FILE);
-      if (data && typeof data === "object" && !Array.isArray(data) && Object.keys(data).length === 0) {
-        try {
-          fs2.unlinkSync(TOKENS_FILE);
-        } catch {
-        }
-        return {};
-      }
-      let needsMigration = false;
-      const migrated = {};
-      for (const [key, val] of Object.entries(data)) {
-        if (!key.startsWith("http")) {
-          migrated[`https://${key}`] = val;
-          needsMigration = true;
-        } else {
-          migrated[key] = val;
-        }
-      }
-      if (needsMigration) {
-        fs2.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
-        return migrated;
-      }
-      return data;
-    }
-  } catch {
-  }
-  return {};
-}
-function saveAllTokens(tokens) {
-  ensureDir();
-  if (Object.keys(tokens).length === 0) {
-    try {
-      fs2.unlinkSync(TOKENS_FILE);
-    } catch {
-    }
-    return;
-  }
-  fs2.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
-  try {
-    fs2.chmodSync(TOKENS_FILE, 384);
-  } catch {
-  }
-}
-function loadToken(hostUrl) {
-  const tokens = loadAllTokens();
-  const entry = tokens[hostUrl];
-  if (!entry || !entry.token) return null;
-  return { host: hostUrl, token: entry.token, updatedAt: entry.updatedAt };
-}
-function saveToken(token, hostUrl) {
-  const tokens = loadAllTokens();
-  tokens[hostUrl] = { token, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  saveAllTokens(tokens);
-  logger.info(`Token saved for ${hostUrl}`);
-}
-function clearToken(hostUrl) {
-  const tokens = loadAllTokens();
-  delete tokens[hostUrl];
-  saveAllTokens(tokens);
-}
-function getAuthStatus(hostUrl) {
-  const cached = loadToken(hostUrl);
-  if (cached) {
-    const ageMs = Date.now() - new Date(cached.updatedAt).getTime();
-    const hours = Math.round(ageMs / 36e5);
-    return { authenticated: true, host: hostUrl, tokenAge: `${hours}h ago`, source: "cache" };
-  }
-  return { authenticated: false, host: hostUrl };
+function invalidateAccessTokenForRetry(hostUrl) {
+  const payload = load(hostUrl);
+  if (!payload) return;
+  save(hostUrl, { ...payload, accessExpiresAt: (/* @__PURE__ */ new Date(0)).toISOString() });
+  logger.info(`auth: marked access token stale for retry on ${hostUrl}`);
 }
 async function getToken(hostUrl) {
   if (!hostUrl) {
@@ -361,11 +262,6 @@ async function getToken(hostUrl) {
 Run: ae-cli config set-host <url>`
     );
   }
-  const cached = loadToken(hostUrl);
-  if (cached && cached.token) {
-    logger.info(`Using cached token for ${hostUrl}`);
-    return cached.token;
-  }
   try {
     const secureToken = await getValidAccessToken(hostUrl);
     logger.info(`Using secure-store token for ${hostUrl}`);
@@ -391,9 +287,6 @@ export {
   SecureStoreAuthError,
   resolveHost,
   validateToken,
-  loadToken,
-  saveToken,
-  clearToken,
-  getAuthStatus,
+  invalidateAccessTokenForRetry,
   getToken
 };

package/dist/chunk-V5R5UIRM.js

@@ -0,0 +1,195 @@
+import {
+  PermissionError
+} from "./chunk-NOO24N7W.js";
+import {
+  clearCliToken,
+  getCliToken
+} from "./chunk-OCQPQYHZ.js";
+import {
+  logger,
+  safeJsonParse
+} 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, 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 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));
+    }
+  }
+  return url.toString();
+}
+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 parseCapabilityResponse(text) {
+  if (!text) return void 0;
+  try {
+    return safeJsonParse(text);
+  } catch {
+    return text;
+  }
+}
+function unwrapCapabilityEnvelope(body) {
+  if (body == null) {
+    throw new CapabilityGatewayError("Empty capability gateway response");
+  }
+  if (typeof body.ok === "boolean") {
+    if (body.ok) {
+      return body.data;
+    }
+    const err = body.error ?? {};
+    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,
+    "Accept": "application/json",
+    "X-Source": "ae-cli"
+  };
+  const init = { method, headers };
+  if (body !== void 0 && method !== "GET") {
+    headers["Content-Type"] = "application/json";
+    init.body = JSON.stringify(body);
+  }
+  return fetch(url, init);
+}
+async function requestMultipartOnce(url, token, form) {
+  return fetch(url, {
+    method: "POST",
+    headers: {
+      "cli-token": token,
+      "Accept": "application/json",
+      "X-Source": "ae-cli"
+    },
+    body: form
+  });
+}
+async function callGateway(host, domain, pathAfterV1, method, body) {
+  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1);
+  const token = await getCliToken(host);
+  let resp = await requestOnce(url, method, token, body);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    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}
+`);
+    resp = await requestOnce(url, method, newToken, body);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+async function executeCapability(host, domain, capabilityId, input = {}) {
+  return callGateway(host, domain, `capabilities/${capabilityId}/execute`, "POST", { input });
+}
+async function uploadInputFile(host, domain, projectId, purpose, filePath) {
+  const fileBytes = await readFile(filePath);
+  return uploadInputFileBytes(host, domain, projectId, purpose, fileBytes, basename(filePath));
+}
+async function uploadInputFileBytes(host, domain, projectId, purpose, bytes, filename, contentType = "application/octet-stream") {
+  const url = buildCapabilityGatewayUrl(host, domain, "input-files");
+  const fileBuffer = bytes instanceof ArrayBuffer ? bytes : bytes.buffer.slice(
+    bytes.byteOffset,
+    bytes.byteOffset + bytes.byteLength
+  );
+  const form = new FormData();
+  form.append("project_id", String(projectId));
+  form.append("purpose", purpose);
+  form.append("file", new Blob([fileBuffer], { type: contentType }), filename);
+  const token = await getCliToken(host);
+  let resp = await requestMultipartOnce(url, token, form);
+  if (resp.status === 403) {
+    throw new PermissionError(await permissionMessage(resp));
+  }
+  if (resp.status === 401) {
+    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}
+`);
+    resp = await requestMultipartOnce(url, newToken, form);
+    if (resp.status === 403) {
+      throw new PermissionError(await permissionMessage(resp));
+    }
+    if (!resp.ok) {
+      await throwCapabilityHttpError(resp);
+    }
+  } else if (!resp.ok) {
+    await throwCapabilityHttpError(resp);
+  }
+  return unwrapCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
+}
+
+export {
+  CapabilityGatewayError,
+  buildCapabilityGatewayUrl,
+  executeCapability,
+  uploadInputFile,
+  uploadInputFileBytes
+};

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

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

package/dist/{cli-token-6AGEDJF4.js → cli-token-OZXHC3U2.js}

@@ -3,9 +3,9 @@ import {
   getCliToken,
   mintCliToken,
   setCliTokenManual
-} from "./chunk-FPE5LGVU.js";
-import "./chunk-U6QPKCN3.js";
-import "./chunk-WPXHCP4A.js";
+} from "./chunk-OCQPQYHZ.js";
+import "./chunk-PFJFZVCK.js";
+import "./chunk-65DKFJZB.js";
 export {
   clearCliToken,
   getCliToken,

package/dist/{client-VTJMUZ4O.js → client-7L735LVY.js}

@@ -7,9 +7,9 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-E34XH4GW.js";
-import "./chunk-U6QPKCN3.js";
-import "./chunk-WPXHCP4A.js";
+} from "./chunk-F3ZDMC2W.js";
+import "./chunk-PFJFZVCK.js";
+import "./chunk-65DKFJZB.js";
 export {
   httpDelete,
   httpGet,

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

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

package/dist/index.js

@@ -1,32 +1,33 @@
 import {
   TeAgentApiError,
   TeAgentCredentialsError
-} from "./chunk-H52CSLJW.js";
+} from "./chunk-4FQ36OGO.js";
 import {
   printError,
   printOutput
-} from "./chunk-YACCPUNQ.js";
+} from "./chunk-ONOA6DYB.js";
 import {
+  CapabilityGatewayError,
   executeCapability,
   uploadInputFileBytes
-} from "./chunk-4EUZRJPO.js";
+} from "./chunk-2OW2RENH.js";
 import {
   PermissionError
 } from "./chunk-NOO24N7W.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-FPE5LGVU.js";
+} from "./chunk-OCQPQYHZ.js";
 import {
   SecureStoreAuthError,
   resolveHost
-} from "./chunk-U6QPKCN3.js";
+} from "./chunk-PFJFZVCK.js";
 import {
   getActiveHost,
   getConfigDir,
   logger,
   safeJsonParse
-} from "./chunk-WPXHCP4A.js";
+} from "./chunk-65DKFJZB.js";
 
 // src/index.ts
 import { Command as CommanderCommand } from "commander";
@@ -90,6 +91,8 @@ async function runCommand(cmd, opts, globalOpts) {
       printError("config", message, err.hint);
     } else if (err instanceof PermissionError) {
       printError("permission", message);
+    } else if (err instanceof CapabilityGatewayError) {
+      printError("api", message, err.hint, err.code);
     } else if (err instanceof SecureStoreAuthError) {
       printError("auth", message, "Run: ae-cli auth login");
     } else if (err instanceof TeAgentApiError) {
@@ -117,7 +120,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _clientModule = null;
   async function getClient() {
     if (!_clientModule) {
-      _clientModule = await import("./client-VTJMUZ4O.js");
+      _clientModule = await import("./client-7L735LVY.js");
     }
     return _clientModule;
   }
@@ -165,7 +168,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
     },
     async token() {
-      const { getToken } = await import("./auth-I2G7OAU2.js");
+      const { getToken } = await import("./auth-IDPKDFSY.js");
       return getToken(ctx.host());
     },
     host() {
@@ -2998,57 +3001,57 @@ program.name("ae-cli").version(version).description("CLI tool for ThinkingAI (AE
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-WWX3Z6RP.js");
+    const teAnalysis = await import("./te-analysis-CRPFK3LX.js");
     commands.push(...teAnalysis.default);
   } catch {
   }
   try {
-    const teAudience = await import("./te-audience-UXGHUVBB.js");
+    const teAudience = await import("./te-audience-RO2IZOUC.js");
     commands.push(...teAudience.default);
   } catch {
   }
   try {
-    const teMeta = await import("./te-meta-LJZBOSMO.js");
+    const teMeta = await import("./te-meta-5ESSQ5B3.js");
     commands.push(...teMeta.default);
   } catch {
   }
   try {
-    const teCommon = await import("./te-common-7XXH73MF.js");
+    const teCommon = await import("./te-common-PUXBUPOL.js");
     commands.push(...teCommon.default);
   } catch {
   }
   try {
-    const engage = await import("./te-engage-NCFAQFX3.js");
+    const engage = await import("./te-engage-YPQIVF5H.js");
     commands.push(...engage.default);
   } catch {
   }
   try {
-    const community = await import("./te-community-QKE67HR2.js");
+    const community = await import("./te-community-NPDZQKMY.js");
     commands.push(...community.default);
   } catch {
   }
   try {
-    const dataops = await import("./te-dataops-6W7NNYST.js");
+    const dataops = await import("./te-dataops-6KWLFNV4.js");
     commands.push(...dataops.default);
   } catch {
   }
   try {
-    const teKb = await import("./te-kb-K5BQYUCM.js");
+    const teKb = await import("./te-kb-DOGDQIU4.js");
     commands.push(...teKb.default);
   } catch {
   }
   try {
-    const teTeam = await import("./te-team-DHK5R7MV.js");
+    const teTeam = await import("./te-team-SOVKZIDD.js");
     commands.push(...teTeam.default);
   } catch {
   }
   try {
-    const teAgent = await import("./te-agent-QPZTLHPH.js");
+    const teAgent = await import("./te-agent-OYNNTJDU.js");
     commands.push(...teAgent.default);
   } catch {
   }
   try {
-    const metadata = await import("./metadata-JZ2OTWBK.js");
+    const metadata = await import("./metadata-XWTEGEN2.js");
     commands.push(...metadata.default);
   } catch {
   }
@@ -3056,35 +3059,35 @@ async function loadCommands() {
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-RDN6D5HU.js");
+    const { registerAuth } = await import("./auth-A2XXG5K4.js");
     registerAuth(program);
   } catch {
   }
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-2SDTLGOC.js");
+    const { registerConfig } = await import("./config-SXD2JKSL.js");
     registerConfig(program);
   } catch {
   }
 }
 async function registerApiCommand() {
   try {
-    const { registerApi } = await import("./raw-NGYHAL3F.js");
+    const { registerApi } = await import("./raw-IANB4AV5.js");
     registerApi(program);
   } catch {
   }
 }
 async function registerSyncCommand() {
   try {
-    const { registerSync } = await import("./sync-JVLX6TGW.js");
+    const { registerSync } = await import("./sync-4HQ3CXSK.js");
     registerSync(program);
   } catch {
   }
 }
 async function registerModelCommand() {
   try {
-    const { registerModel } = await import("./model-ZYMRN4VS.js");
+    const { registerModel } = await import("./model-3OVX42DA.js");
     registerModel(program);
   } catch {
   }