@thinkingai/ae-cli 6.0.32 → 6.0.34

package/dist/{chunk-KGJQCYVC.js → chunk-LCXU3AAT.js}

@@ -1,8 +1,10 @@
 import {
   getSandboxClusterInfoFilePath,
-  logger,
   safeReadJsonFile
-} from "./chunk-YCLVYFK7.js";
+} from "./chunk-V6FR6WTW.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
 
 // src/core/cluster-info.ts
 import fs from "fs";

package/dist/chunk-LYVNONC4.js

@@ -0,0 +1,86 @@
+// src/core/logger.ts
+import fs from "fs";
+import path from "path";
+var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
+var Logger = class {
+  logDir;
+  date;
+  constructor() {
+    this.logDir = LOG_DIR;
+    this.date = this.today();
+    this.ensureDir();
+  }
+  today() {
+    const d = /* @__PURE__ */ new Date();
+    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
+  }
+  timestamp() {
+    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
+  }
+  ensureDir() {
+    if (!fs.existsSync(this.logDir)) {
+      fs.mkdirSync(this.logDir, { recursive: true });
+    }
+  }
+  filePath(level) {
+    const today = this.today();
+    if (today !== this.date) {
+      this.date = today;
+    }
+    return path.join(this.logDir, `${this.date}_${level}.log`);
+  }
+  /**
+   * Write a log entry to file (not printed to the console; console output is handled by existing process.stderr.write calls)
+   */
+  write(level, message) {
+    const ts = this.timestamp();
+    const line = `[${ts}] ${message}
+`;
+    try {
+      fs.appendFileSync(this.filePath(level), line);
+    } catch {
+    }
+  }
+  /** Informational log */
+  info(message) {
+    this.write("info", message);
+  }
+  /** Warning log */
+  warn(message) {
+    this.write("warning", message);
+  }
+  /** Error log */
+  error(message) {
+    this.write("error", message);
+  }
+  /** Log HTTP API request details */
+  api(method, url, status, reqBody, respBody) {
+    const parts = [`API ${method} ${url} \u2192 HTTP ${status}`];
+    if (reqBody !== void 0 && reqBody !== null) {
+      const s = typeof reqBody === "string" ? reqBody : JSON.stringify(reqBody);
+      parts.push(`REQ: ${s.slice(0, 500)}`);
+    }
+    if (respBody !== void 0 && respBody !== null) {
+      const s = typeof respBody === "string" ? respBody : JSON.stringify(respBody);
+      parts.push(`RESP: ${s.slice(0, 500)}`);
+    }
+    this.info(parts.join(" | "));
+  }
+  /** Log command execution (sensitive flags redacted to ***) */
+  command(name, args, sensitiveFlags = []) {
+    const normalizeFlagName = (name2) => name2.toLowerCase().replace(/[-_]/g, "");
+    const explicitSensitive = new Set(Array.from(sensitiveFlags, normalizeFlagName));
+    const SENSITIVE = ["token", "apikey", "secret", "accesstoken", "headers"];
+    const isSensitive = (k) => {
+      const normalized = normalizeFlagName(k);
+      return explicitSensitive.has(normalized) || SENSITIVE.some((s) => normalized.includes(s));
+    };
+    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${k}=${isSensitive(k) ? "***" : JSON.stringify(v)}`).join(" ");
+    this.info(`CMD ${name}${filtered ? " " + filtered : ""}`);
+  }
+};
+var logger = new Logger();
+
+export {
+  logger
+};

package/dist/{chunk-DYOS6YY7.js → chunk-RGXCNC4N.js}

@@ -1,14 +1,16 @@
-import {
-  PermissionError
-} from "./chunk-NOO24N7W.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-2NDGFQHW.js";
+} from "./chunk-E7UXXHO3.js";
 import {
-  logger,
   safeJsonParse
-} from "./chunk-YCLVYFK7.js";
+} from "./chunk-V6FR6WTW.js";
+import {
+  PermissionError
+} from "./chunk-24BAVOX3.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
 
 // src/core/capability-api.ts
 import { readFile } from "fs/promises";
@@ -147,11 +149,11 @@ async function requestMultipartOnce(url, token, form) {
     body: form
   });
 }
-async function callGateway(host, domain, pathAfterV1, method, body) {
-  return (await callGatewayWithEnvelope(host, domain, pathAfterV1, method, body)).data;
+async function callGateway(host, domain, pathAfterV1, method, body, queryParams = {}) {
+  return (await callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams)).data;
 }
-async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body) {
-  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1);
+async function callGatewayWithEnvelope(host, domain, pathAfterV1, method, body, queryParams = {}) {
+  const url = buildCapabilityGatewayUrl(host, domain, pathAfterV1, queryParams);
   const token = await getCliToken(host);
   let resp = await requestOnce(url, method, token, body);
   let permissionMsg;
@@ -212,11 +214,18 @@ async function requestCapabilityGatewayWithEnvelope(host, domain, pathAfterV1, m
   const resp = await fetchCapabilityGateway(host, domain, pathAfterV1, method, body);
   return parseCapabilityEnvelope(parseCapabilityResponse(await resp.text()));
 }
-async function listCapabilities(host, domain) {
-  return callGateway(host, domain, "capabilities", "GET");
+async function listCapabilities(host, domain, projectId) {
+  return callGateway(host, domain, "capabilities", "GET", void 0, { project_id: projectId });
 }
-async function inspectCapability(host, domain, capabilityId) {
-  return callGateway(host, domain, `capabilities/${capabilityId}`, "GET");
+async function inspectCapability(host, domain, capabilityId, projectId) {
+  return callGateway(
+    host,
+    domain,
+    `capabilities/${capabilityId}`,
+    "GET",
+    void 0,
+    { project_id: projectId }
+  );
 }
 async function executeCapability(host, domain, capabilityId, input = {}) {
   return callGateway(host, domain, `capabilities/${capabilityId}/execute`, "POST", { input });

package/dist/{chunk-YCLVYFK7.js → chunk-V6FR6WTW.js}

@@ -1,95 +1,40 @@
-// src/core/logger.ts
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
+
+// src/core/json-utils.ts
 import fs from "fs";
-import path from "path";
-var LOG_DIR = path.join(process.env.HOME || "", ".ae-cli", "log");
-var Logger = class {
-  logDir;
-  date;
-  constructor() {
-    this.logDir = LOG_DIR;
-    this.date = this.today();
-    this.ensureDir();
-  }
-  today() {
-    const d = /* @__PURE__ */ new Date();
-    return `${d.getFullYear()}${String(d.getMonth() + 1).padStart(2, "0")}${String(d.getDate()).padStart(2, "0")}`;
-  }
-  timestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").split(".")[0];
-  }
-  ensureDir() {
-    if (!fs.existsSync(this.logDir)) {
-      fs.mkdirSync(this.logDir, { recursive: true });
-    }
-  }
-  filePath(level) {
-    const today = this.today();
-    if (today !== this.date) {
-      this.date = today;
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var JSONbig = require2("json-bigint");
+var jsonParser = JSONbig({ storeAsString: true });
+var INTEGER_TOKEN = /^-?(?:0|[1-9]\d*)$/;
+function normalizeParsedNumbers(lossless, native) {
+  if (typeof lossless === "string" && typeof native === "number") {
+    if (INTEGER_TOKEN.test(lossless) && !Number.isSafeInteger(native)) {
+      return lossless;
     }
-    return path.join(this.logDir, `${this.date}_${level}.log`);
+    return native;
   }
-  /**
-   * Write a log entry to file (not printed to the console; console output is handled by existing process.stderr.write calls)
-   */
-  write(level, message) {
-    const ts = this.timestamp();
-    const line = `[${ts}] ${message}
-`;
-    try {
-      fs.appendFileSync(this.filePath(level), line);
-    } catch {
+  if (Array.isArray(lossless) && Array.isArray(native)) {
+    for (let index = 0; index < lossless.length; index++) {
+      lossless[index] = normalizeParsedNumbers(lossless[index], native[index]);
     }
+    return lossless;
   }
-  /** Informational log */
-  info(message) {
-    this.write("info", message);
-  }
-  /** Warning log */
-  warn(message) {
-    this.write("warning", message);
-  }
-  /** Error log */
-  error(message) {
-    this.write("error", message);
-  }
-  /** Log HTTP API request details */
-  api(method, url, status, reqBody, respBody) {
-    const parts = [`API ${method} ${url} \u2192 HTTP ${status}`];
-    if (reqBody !== void 0 && reqBody !== null) {
-      const s = typeof reqBody === "string" ? reqBody : JSON.stringify(reqBody);
-      parts.push(`REQ: ${s.slice(0, 500)}`);
-    }
-    if (respBody !== void 0 && respBody !== null) {
-      const s = typeof respBody === "string" ? respBody : JSON.stringify(respBody);
-      parts.push(`RESP: ${s.slice(0, 500)}`);
+  if (lossless !== null && native !== null && typeof lossless === "object" && typeof native === "object") {
+    for (const key of Object.keys(lossless)) {
+      lossless[key] = normalizeParsedNumbers(lossless[key], native[key]);
     }
-    this.info(parts.join(" | "));
   }
-  /** Log command execution (sensitive flags redacted to ***) */
-  command(name, args) {
-    const SENSITIVE = ["token", "apikey", "secret", "accesstoken", "headers"];
-    const isSensitive = (k) => {
-      const lk = k.toLowerCase();
-      return SENSITIVE.some((s) => lk.includes(s));
-    };
-    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${k}=${isSensitive(k) ? "***" : JSON.stringify(v)}`).join(" ");
-    this.info(`CMD ${name}${filtered ? " " + filtered : ""}`);
-  }
-};
-var logger = new Logger();
-
-// src/core/json-utils.ts
-import fs2 from "fs";
-import { createRequire } from "module";
-var require2 = createRequire(import.meta.url);
-var JSONbig = require2("json-bigint");
-var jsonParser = JSONbig({ storeAsString: true });
+  return lossless;
+}
 function safeJsonParse(text) {
-  return jsonParser.parse(text);
+  const lossless = jsonParser.parse(text);
+  return normalizeParsedNumbers(lossless, JSON.parse(text));
 }
 function safeReadJsonFile(filePath) {
-  const content = fs2.readFileSync(filePath, "utf-8");
+  const content = fs.readFileSync(filePath, "utf-8");
   return safeJsonParse(content);
 }
 
@@ -104,11 +49,12 @@ function normalizeUrl(url) {
 
 // src/core/config.ts
 import fs3 from "fs";
-import path2 from "path";
+import path from "path";
 
 // src/core/sandbox-runtime.ts
 import { homedir } from "os";
 import { join } from "path";
+import fs2 from "fs";
 var LINUX_SANDBOX_RUNTIME_ROOT = "/home/ta/te_agent_ta";
 function getDefaultSandboxRuntimeRoot() {
   if (process.platform === "linux") {
@@ -128,13 +74,25 @@ function getSandboxCliTokenFilePath() {
 function getSandboxClusterInfoFilePath() {
   return join(getSandboxAeConfigDir(), "cluster-info.json");
 }
+function isAeSandboxRuntime() {
+  if (process.env.SANDBOX_RUNTIME_ROOT) {
+    return true;
+  }
+  try {
+    if (fs2.existsSync(getSandboxCliTokenFilePath())) {
+      return true;
+    }
+  } catch {
+  }
+  return false;
+}
 
 // src/core/config.ts
-var CONFIG_DIR = path2.join(process.env.HOME || "", ".ae-cli");
-var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
+var CONFIG_DIR = path.join(process.env.HOME || "", ".ae-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
 function sandboxCliTokenCandidatePaths() {
   const paths = [getSandboxCliTokenFilePath()];
-  const homeFallback = path2.join(process.env.HOME || "", ".ae-config", "cli-token.json");
+  const homeFallback = path.join(process.env.HOME || "", ".ae-config", "cli-token.json");
   if (!paths.includes(homeFallback)) {
     paths.push(homeFallback);
   }
@@ -289,12 +247,12 @@ function getConfigDir() {
 }
 
 export {
-  logger,
   safeJsonParse,
   safeReadJsonFile,
   normalizeUrl,
   getSandboxRuntimeRoot,
   getSandboxClusterInfoFilePath,
+  isAeSandboxRuntime,
   getFallbackCliToken,
   loadConfig,
   saveConfig,

package/dist/chunk-VTWMIC5L.js

@@ -0,0 +1,27 @@
+// src/core/package-info.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function getLocalCliPackageInfo() {
+  let dir = path.dirname(fileURLToPath(import.meta.url));
+  for (let i = 0; i < 8; i += 1) {
+    const candidate = path.join(dir, "package.json");
+    try {
+      if (fs.existsSync(candidate)) {
+        const pkg = JSON.parse(fs.readFileSync(candidate, "utf8"));
+        if (pkg.name && pkg.version && String(pkg.name).includes("ae-cli")) {
+          return { name: pkg.name, version: pkg.version };
+        }
+      }
+    } catch {
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return { name: "@tant/ae-cli", version: "0.0.0" };
+}
+
+export {
+  getLocalCliPackageInfo
+};

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

@@ -4,15 +4,18 @@ import {
   getCliToken,
   localRenewDate,
   mintCliToken,
+  peekCliToken,
   setCliTokenManual
-} from "./chunk-2NDGFQHW.js";
-import "./chunk-AJTH7LT3.js";
-import "./chunk-YCLVYFK7.js";
+} from "./chunk-E7UXXHO3.js";
+import "./chunk-IR4ZLVPW.js";
+import "./chunk-V6FR6WTW.js";
+import "./chunk-LYVNONC4.js";
 export {
   _resetRenewMemoryForTest,
   clearCliToken,
   getCliToken,
   localRenewDate,
   mintCliToken,
+  peekCliToken,
   setCliTokenManual
 };

package/dist/{client-2643Z5AG.js → client-PP5FETMW.js}

@@ -7,9 +7,10 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-KCA6BA5D.js";
-import "./chunk-AJTH7LT3.js";
-import "./chunk-YCLVYFK7.js";
+} from "./chunk-DB4Q3ANU.js";
+import "./chunk-IR4ZLVPW.js";
+import "./chunk-V6FR6WTW.js";
+import "./chunk-LYVNONC4.js";
 export {
   httpDelete,
   httpGet,

package/dist/community-report-client-KK2QBANO.js

@@ -0,0 +1,145 @@
+import {
+  CommunityReportError
+} from "./chunk-24BAVOX3.js";
+import {
+  logger
+} from "./chunk-LYVNONC4.js";
+
+// src/core/community-report-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+async function communityReport(endpoint, rawBody, options = {}) {
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const requestBytes = Buffer.byteLength(rawBody, "utf8");
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  let responseText;
+  try {
+    response = await fetchImpl(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      },
+      body: rawBody,
+      redirect: "error",
+      signal: controller.signal
+    });
+    responseText = await response.text();
+  } catch (error) {
+    const timedOut = controller.signal.aborted || isAbortError(error);
+    logCommunityReport(endpoint, response?.status ?? "unavailable", requestBytes, 0);
+    if (timedOut) {
+      throw new CommunityReportError(
+        `Community data report timed out after ${timeoutMs} ms. Delivery state is unknown.`,
+        {
+          code: "COMMUNITY_REPORT_TIMEOUT",
+          hint: "Check downstream query or storage before deciding whether to submit again. The CLI did not retry.",
+          meta: { persistence_verified: false, retry_attempted: false },
+          cause: error
+        }
+      );
+    }
+    throw new CommunityReportError("Community data report request failed before a response was received.", {
+      code: "COMMUNITY_REPORT_NETWORK_ERROR",
+      hint: "Verify the endpoint and network path. The CLI did not retry.",
+      meta: { persistence_verified: false, retry_attempted: false },
+      cause: error
+    });
+  } finally {
+    clearTimeout(timeout);
+  }
+  const responseBytes = Buffer.byteLength(responseText, "utf8");
+  logCommunityReport(endpoint, response.status, requestBytes, responseBytes);
+  const responseBody = parseResponseBody(responseText, response.status);
+  if (!response.ok) {
+    if (response.status === 400) {
+      const returnMessage = getReturnMessage(responseBody);
+      throw new CommunityReportError(returnMessage ?? "Iris rejected the community data report.", {
+        code: getReturnCode(responseBody) ?? "COMMUNITY_REPORT_HTTP_400",
+        httpStatus: response.status,
+        meta: safeResponseMeta(requestBytes, responseBytes)
+      });
+    }
+    throw new CommunityReportError(`Iris sync endpoint returned HTTP ${response.status}.`, {
+      code: `COMMUNITY_REPORT_HTTP_${response.status}`,
+      httpStatus: response.status,
+      hint: response.status >= 500 ? "The server response was suppressed. Check Iris or gateway logs; the CLI did not retry." : void 0,
+      meta: safeResponseMeta(requestBytes, responseBytes)
+    });
+  }
+  if (!isRecord(responseBody) || typeof responseBody.return_code !== "number") {
+    throw new CommunityReportError("Iris sync endpoint returned an invalid API response: missing numeric return_code.", {
+      code: "COMMUNITY_REPORT_INVALID_RESPONSE",
+      httpStatus: response.status,
+      meta: safeResponseMeta(requestBytes, responseBytes)
+    });
+  }
+  if (responseBody.return_code !== 0) {
+    throw new CommunityReportError(
+      getReturnMessage(responseBody) ?? "Iris rejected the community data report.",
+      {
+        code: responseBody.return_code,
+        httpStatus: response.status,
+        meta: safeResponseMeta(requestBytes, responseBytes)
+      }
+    );
+  }
+  return {
+    return_code: 0,
+    return_message: getReturnMessage(responseBody) ?? "success",
+    http_status: response.status,
+    request_bytes: requestBytes,
+    response_bytes: responseBytes
+  };
+}
+function parseResponseBody(text, httpStatus) {
+  if (!text.trim()) {
+    if (httpStatus >= 500) return void 0;
+    throw new CommunityReportError("Iris sync endpoint returned an empty API response.", {
+      code: "COMMUNITY_REPORT_INVALID_RESPONSE",
+      httpStatus
+    });
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    if (httpStatus >= 500) return void 0;
+    throw new CommunityReportError("Iris sync endpoint returned a non-JSON API response.", {
+      code: "COMMUNITY_REPORT_INVALID_RESPONSE",
+      httpStatus
+    });
+  }
+}
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function getReturnCode(value) {
+  if (!isRecord(value)) return void 0;
+  return typeof value.return_code === "number" || typeof value.return_code === "string" ? value.return_code : void 0;
+}
+function getReturnMessage(value) {
+  if (!isRecord(value)) return void 0;
+  return typeof value.return_message === "string" && value.return_message.trim() ? value.return_message.trim() : void 0;
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError";
+}
+function safeResponseMeta(requestBytes, responseBytes) {
+  return {
+    request_bytes: requestBytes,
+    response_bytes: responseBytes,
+    persistence_verified: false,
+    retry_attempted: false
+  };
+}
+function logCommunityReport(endpoint, status, requestBytes, responseBytes) {
+  logger.info(
+    `COMMUNITY_REPORT POST ${endpoint} status=${status} request_bytes=${requestBytes} response_bytes=${responseBytes}`
+  );
+}
+export {
+  CommunityReportError,
+  communityReport
+};

package/dist/{config-7UZWDE74.js → config-RCCGHHYA.js}

@@ -1,20 +1,23 @@
 import {
   printError,
   printOutput
-} from "./chunk-TNW2CI4W.js";
+} from "./chunk-IMMGMU54.js";
 import {
   GLOBAL_QUERY_CONFIG_KEY,
   getAnalysisMappingPathForClusterMode,
   getClusterInfoFilePath,
   isGlobalQueryModeEnabled,
   setGlobalQueryModeEnabled
-} from "./chunk-KGJQCYVC.js";
+} from "./chunk-LCXU3AAT.js";
+import "./chunk-E7UXXHO3.js";
+import "./chunk-IR4ZLVPW.js";
 import {
   addHost,
   loadConfig,
   normalizeUrl,
   setActiveHost
-} from "./chunk-YCLVYFK7.js";
+} from "./chunk-V6FR6WTW.js";
+import "./chunk-LYVNONC4.js";
 
 // src/commands/config.ts
 function registerConfig(program) {