@thinkingai/ae-cli 1.0.27 → 1.0.28

package/dist/chunk-OJDNO5QY.js

@@ -0,0 +1,63 @@
+import {
+  getMcpToken
+} from "./chunk-WCHI7725.js";
+import {
+  safeJsonParse
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/mcp-access.ts
+function buildUrl(host, path, params = {}) {
+  const base = host.replace(/\/$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${p}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function parseKbResponse(resp, text) {
+  if (resp.status === 401 || resp.status === 403) {
+    throw new Error(`KB MCP token auth failed: HTTP ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(text);
+  if (data.return_code === -1001) {
+    throw new Error(`KB MCP token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`AE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function fetchWithMcpToken(input, init, mcpToken) {
+  const headers = new Headers(init.headers);
+  headers.set("mcp-token", mcpToken);
+  const resp = await fetch(input, { ...init, headers });
+  return parseKbResponse(resp, await resp.text());
+}
+async function kbApi(ctx, method, path, params = {}, body) {
+  const host = ctx.host();
+  const mcpToken = await getMcpToken(host);
+  const upperMethod = method.toUpperCase();
+  return fetchWithMcpToken(buildUrl(host, path, params), {
+    method: upperMethod,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: upperMethod === "GET" ? void 0 : JSON.stringify(body ?? {})
+  }, mcpToken);
+}
+async function kbUpload(ctx, path, form, params = {}) {
+  const host = ctx.host();
+  const mcpToken = await getMcpToken(host);
+  return fetchWithMcpToken(buildUrl(host, path, params), {
+    method: "POST",
+    body: form
+  }, mcpToken);
+}
+
+export {
+  kbApi,
+  kbUpload
+};

package/dist/chunk-SRJIAOBN.js

@@ -0,0 +1,244 @@
+// 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 */
+  command(name, args) {
+    const filtered = Object.entries(args).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => `--${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 });
+function safeJsonParse(text) {
+  return jsonParser.parse(text);
+}
+function safeReadJsonFile(filePath) {
+  const content = fs2.readFileSync(filePath, "utf-8");
+  return safeJsonParse(content);
+}
+
+// src/core/config.ts
+import fs3 from "fs";
+import path2 from "path";
+
+// src/core/sandbox-runtime.ts
+import { homedir } from "os";
+import { join } from "path";
+var LINUX_SANDBOX_RUNTIME_ROOT = "/home/ta/te_agent_ta";
+function getDefaultSandboxRuntimeRoot() {
+  if (process.platform === "linux") {
+    return LINUX_SANDBOX_RUNTIME_ROOT;
+  }
+  return homedir();
+}
+function getSandboxRuntimeRoot() {
+  return process.env.SANDBOX_RUNTIME_ROOT || getDefaultSandboxRuntimeRoot();
+}
+function getSandboxAeConfigDir() {
+  return join(getSandboxRuntimeRoot(), ".ae-config");
+}
+function getSandboxMcpTokenFilePath() {
+  return join(getSandboxAeConfigDir(), "mcp-token.json");
+}
+function getSandboxClusterInfoFilePath() {
+  return join(getSandboxAeConfigDir(), "cluster-info.json");
+}
+
+// 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");
+  if (!paths.includes(homeFallback)) {
+    paths.push(homeFallback);
+  }
+  return paths;
+}
+function readSandboxMcpTokenEntry() {
+  for (const file of sandboxMcpTokenCandidatePaths()) {
+    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"];
+        if (url && token) {
+          return { url, token };
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function ensureDir() {
+  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function forceMigrateFromFallback() {
+  const entry = readSandboxMcpTokenEntry();
+  if (!entry) return null;
+  return { [entry.url]: entry.token };
+}
+function getFallbackMcpToken(hostUrl) {
+  const store = forceMigrateFromFallback();
+  if (!store) return null;
+  if (hostUrl && store[hostUrl]) return store[hostUrl];
+  const entries = Object.values(store);
+  if (entries.length === 1) return entries[0];
+  return null;
+}
+function loadConfig() {
+  try {
+    if (fs3.existsSync(CONFIG_FILE)) {
+      const raw = safeReadJsonFile(CONFIG_FILE);
+      if (raw.defaultHost && !raw.activeHost) {
+        const migrated = migrateConfig(raw);
+        saveConfig(migrated);
+        return migrated;
+      }
+      return raw;
+    }
+  } catch (err) {
+    logger.error(`Error loading config: ${err.message}`);
+    console.error(`Error loading config: ${err.message}`);
+  }
+  return { activeHost: "", hosts: {} };
+}
+function migrateConfig(old) {
+  const hosts = {};
+  const oldHost = old.defaultHost;
+  if (old.hosts) {
+    for (const [key, val] of Object.entries(old.hosts)) {
+      const url = key.startsWith("http") ? key : `https://${key}`;
+      hosts[url] = val;
+    }
+  }
+  const activeHost = oldHost.startsWith("http") ? oldHost : `https://${oldHost}`;
+  if (!hosts[activeHost]) {
+    hosts[activeHost] = { label: "default" };
+  }
+  return { activeHost, hosts };
+}
+function saveConfig(config) {
+  ensureDir();
+  fs3.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  logger.info(`Config saved: activeHost=${config.activeHost}, hosts=${Object.keys(config.hosts).length}`);
+}
+function getActiveHost() {
+  const config = loadConfig();
+  if (config.activeHost) return config.activeHost;
+  return readSandboxMcpTokenEntry()?.url ?? "";
+}
+function setActiveHost(url) {
+  const config = loadConfig();
+  if (!config.hosts[url]) {
+    throw new Error(`Host ${url} is not in the configured hosts list. Add it first.`);
+  }
+  config.activeHost = url;
+  saveConfig(config);
+}
+function addHost(url, label) {
+  const config = loadConfig();
+  assertUniqueHostLabel(config, label, url);
+  config.hosts[url] = { label };
+  if (!config.activeHost) {
+    config.activeHost = url;
+  }
+  saveConfig(config);
+}
+function assertUniqueHostLabel(config, label, excludeUrl) {
+  const duplicate = Object.entries(config.hosts).find(([url, entry]) => url !== excludeUrl && entry.label === label);
+  if (duplicate) {
+    throw new Error(`Label already exists: ${label}. Rename the existing label first: ${duplicate[0]}`);
+  }
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+export {
+  logger,
+  safeJsonParse,
+  safeReadJsonFile,
+  getSandboxRuntimeRoot,
+  getSandboxClusterInfoFilePath,
+  getFallbackMcpToken,
+  loadConfig,
+  saveConfig,
+  getActiveHost,
+  setActiveHost,
+  addHost,
+  getConfigDir
+};

package/dist/{chunk-2NGWYMLB.js → chunk-WCHI7725.js}

@@ -1,20 +1,18 @@
 import {
-  getToken
-} from "./chunk-SRRUNQIM.js";
+  getAnalysisMappingPathForClusterMode
+} from "./chunk-GSJGPNKK.js";
 import {
-  forceMigrateFromFallback,
-  getActiveHost,
-  getConfigDir,
-  safeJsonParse,
-  safeReadJsonFile
-} from "./chunk-BI5ZVD6T.js";
+  getToken,
+  loadMcpToken
+} from "./chunk-CAQYQA4R.js";
 import {
-  logger
-} from "./chunk-MNHE6SSI.js";
+  getActiveHost,
+  getFallbackMcpToken,
+  logger,
+  safeJsonParse
+} from "./chunk-SRJIAOBN.js";
 
 // src/core/mcp.ts
-import fs from "fs";
-import path from "path";
 var MCP_PROTOCOL_VERSION = "2025-11-25";
 var JSONRPC_VERSION = "2.0";
 var serviceMappingMap = /* @__PURE__ */ new Map();
@@ -39,6 +37,9 @@ function getMcpMapping(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) {
@@ -56,22 +57,8 @@ var requestIdCounter = 1;
 function genRequestId() {
   return requestIdCounter++;
 }
-var MCP_TOKEN_FILE = path.join(getConfigDir(), "mcp-tokens.json");
 var MCP_TOKEN_GENERATE_PATH = "/v1/ta/mcp/token/generate";
-function loadMcpTokenStore() {
-  try {
-    if (fs.existsSync(MCP_TOKEN_FILE)) {
-      return safeReadJsonFile(MCP_TOKEN_FILE);
-    }
-  } catch {
-  }
-  return {};
-}
-function saveMcpTokenStore(store) {
-  const dir = getConfigDir();
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(MCP_TOKEN_FILE, JSON.stringify(store, null, 2));
-}
+var _mcpTokenCache = /* @__PURE__ */ new Map();
 async function generateMcpToken(hostUrl) {
   const teToken = await getToken(hostUrl);
   const base = hostUrl.replace(/\/+$/, "");
@@ -97,33 +84,38 @@ async function generateMcpToken(hostUrl) {
 }
 async function getMcpToken(hostOverride) {
   const hostUrl = hostOverride || getActiveHost();
-  const store = loadMcpTokenStore();
-  if (store[hostUrl]) {
-    return store[hostUrl];
+  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);
-  const updatedStore = { ...store, [hostUrl]: mcpToken };
-  saveMcpTokenStore(updatedStore);
-  logger.info(`MCP token generated and cached for ${hostUrl}`);
+  _mcpTokenCache.set(hostUrl, mcpToken);
+  logger.info(`MCP token generated and in-process cached for ${hostUrl}`);
   return mcpToken;
 }
 function clearMcpToken(hostUrl) {
-  const store = loadMcpTokenStore();
   if (hostUrl) {
-    delete store[hostUrl];
+    _mcpTokenCache.delete(hostUrl);
   } else {
-    for (const key of Object.keys(store)) {
-      delete store[key];
-    }
+    _mcpTokenCache.clear();
   }
-  saveMcpTokenStore(store);
 }
 function setMcpTokenManual(token, hostUrl) {
-  const store = loadMcpTokenStore();
-  store[hostUrl] = token;
-  saveMcpTokenStore(store);
-  logger.info(`MCP token manually set for ${hostUrl}`);
+  _mcpTokenCache.set(hostUrl, token);
+  logger.info(`MCP token manually set (in-process) for ${hostUrl}`);
 }
 async function validateMcpToken(token, hostUrl) {
   const mapping = getMcpMapping("analysis");
@@ -186,13 +178,16 @@ async function mcpRequest(url, method, params = {}, hostOverride) {
     body: JSON.stringify(body)
   });
   if (!resp.ok) {
-    logger.warn(`MCP request failed (HTTP ${resp.status}) for ${hostUrl}, trying fallback`);
-    const migrated = forceMigrateFromFallback();
-    if (migrated && migrated[hostUrl]) {
-      logger.info(`MCP token refreshed from fallback for ${hostUrl}`);
-      process.stderr.write(`[ae-cli] MCP token refreshed from fallback for ${hostUrl}
+    logger.warn(`MCP request failed (HTTP ${resp.status}) for ${hostUrl}, re-minting token`);
+    if (resp.status === 401 || resp.status === 403) {
+      _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}
 `);
-      headers["mcp-token"] = migrated[hostUrl];
+      headers["mcp-token"] = newToken;
       const retryResp = await fetch(url, {
         method: "POST",
         headers,
@@ -253,7 +248,7 @@ function parseMcpResult(result) {
 export {
   registerMcpMappings,
   resolveMcpUrl,
-  loadMcpTokenStore,
+  getMcpToken,
   clearMcpToken,
   setMcpTokenManual,
   validateMcpToken,

package/dist/{client-IU2E5IOL.js → client-FCMK3XEK.js}

@@ -7,10 +7,9 @@ import {
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-VT6VC4PA.js";
-import "./chunk-SRRUNQIM.js";
-import "./chunk-BI5ZVD6T.js";
-import "./chunk-MNHE6SSI.js";
+} from "./chunk-LU7SXK4Q.js";
+import "./chunk-CAQYQA4R.js";
+import "./chunk-SRJIAOBN.js";
 export {
   httpDelete,
   httpGet,

package/dist/config-64G36TJL.js

@@ -0,0 +1,130 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-CLJF7MQA.js";
+import {
+  GLOBAL_QUERY_CONFIG_KEY,
+  getAnalysisMappingPathForClusterMode,
+  getClusterInfoFilePath,
+  isGlobalQueryModeEnabled,
+  setGlobalQueryModeEnabled
+} from "./chunk-GSJGPNKK.js";
+import {
+  addHost,
+  loadConfig,
+  setActiveHost
+} from "./chunk-SRJIAOBN.js";
+
+// src/commands/config.ts
+function registerConfig(program) {
+  const configCmd = program.command("config").description("AE host and environment configuration").action(() => {
+    printError("config", "Missing subcommand.", "Run: ae-cli config --help");
+    process.exit(1);
+  });
+  configCmd.command("list").description("List configured AE environments").action(() => {
+    printConfigList(program);
+  });
+  configCmd.command("current").description("Show the active AE environment").action(() => {
+    printCurrentConfig(program);
+  });
+  configCmd.command("use <env>").description("Switch active AE environment by exact URL or unique label").action((env) => {
+    useConfigEnv(program, env);
+  });
+  configCmd.command("set-host <url>").description("Set the active AE host non-interactively (adds it if not already configured)").option("--label <label>", "Display label for this host (defaults to the host URL)").action((url, opts) => {
+    const normalized = normalizeUrl(url);
+    const label = opts.label || normalized;
+    addHost(normalized, label);
+    setActiveHost(normalized);
+    printOutput({ activeHost: normalized, label }, program.opts().format || "json");
+  });
+  const clusterMode = configCmd.command("cluster-mode").description("Manage local multi-cluster analysis MCP mode").action(() => {
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("status").description("Show local multi-cluster analysis MCP mode").action(() => {
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("enable").description("Enable local multi-cluster analysis MCP mode").action(() => {
+    setGlobalQueryModeEnabled(true);
+    printClusterModeStatus(program);
+  });
+  clusterMode.command("disable").description("Disable local multi-cluster analysis MCP mode").action(() => {
+    setGlobalQueryModeEnabled(false);
+    printClusterModeStatus(program);
+  });
+}
+function printClusterModeStatus(program) {
+  const enabled = isGlobalQueryModeEnabled();
+  printOutput({
+    [GLOBAL_QUERY_CONFIG_KEY]: enabled,
+    path: getClusterInfoFilePath(),
+    analysisMappingPath: getAnalysisMappingPathForClusterMode(enabled)
+  }, program.opts().format || "json", program.opts().jq);
+}
+function readHostViews() {
+  const config = loadConfig();
+  const hosts = Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+  return { activeHost: config.activeHost, hosts };
+}
+function printConfigList(program) {
+  const { activeHost, hosts } = readHostViews();
+  printOutput({ activeHost, hosts }, program.opts().format || "json", program.opts().jq);
+}
+function printCurrentConfig(program) {
+  const { activeHost, hosts } = readHostViews();
+  const current = hosts.find((h) => h.url === activeHost);
+  if (!current) {
+    failConfig("No active AE environment configured.", "Run: ae-cli config use <env> or ae-cli config list");
+    return;
+  }
+  printOutput({ activeHost: current.url, label: current.label }, program.opts().format || "json", program.opts().jq);
+}
+function useConfigEnv(program, env) {
+  const target = resolveHost(env);
+  if (target.status === "not-found") {
+    failConfig(
+      `No AE environment matched: ${env}`,
+      target.hosts.length > 0 ? `Available environments: ${formatHostOptions(target.hosts)}` : "Run: ae-cli config list"
+    );
+    return;
+  }
+  if (target.status === "duplicate-label") {
+    failConfig(
+      `Duplicate label: ${env}`,
+      `Rename duplicate labels first. Run: ae-cli config list \u2014 ${formatHostOptions(target.matches)}`
+    );
+    return;
+  }
+  setActiveHost(target.host.url);
+  printOutput({ activeHost: target.host.url, label: target.host.label }, program.opts().format || "json", program.opts().jq);
+}
+function resolveHost(env) {
+  const raw = env.trim();
+  const selector = raw.startsWith("http://") || raw.startsWith("https://") ? normalizeUrl(raw) : raw;
+  const { hosts } = readHostViews();
+  const byUrl = hosts.find((h) => h.url === selector);
+  if (byUrl) return { status: "found", host: byUrl };
+  const byLabel = hosts.filter((h) => h.label === raw);
+  if (byLabel.length === 1) return { status: "found", host: byLabel[0] };
+  if (byLabel.length > 1) return { status: "duplicate-label", matches: byLabel };
+  return { status: "not-found", hosts };
+}
+function formatHostOptions(hosts) {
+  return hosts.map((h) => `${h.label} (${h.url})`).join(", ");
+}
+function failConfig(message, hint) {
+  printError("config", message, hint);
+  process.exitCode = 1;
+}
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+export {
+  registerConfig
+};