@thinkingai/ae-cli 1.0.24 → 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-DC66L5AM.js → chunk-SRJIAOBN.js}

@@ -30,7 +30,7 @@ var Logger = class {
     return path.join(this.logDir, `${this.date}_${level}.log`);
   }
   /**
-   * 写入日志到文件（不输出到控制台，控制台由现有 process.stderr.write 负责）
+   * 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();
@@ -41,19 +41,19 @@ var Logger = class {
     } 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);
   }
-  /** 记录 HTTP API 请求详情 */
+  /** 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) {
@@ -66,7 +66,7 @@ var Logger = class {
     }
     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 : ""}`);
@@ -91,48 +91,76 @@ function safeReadJsonFile(filePath) {
 // src/core/config.ts
 import fs3 from "fs";
 import path2 from "path";
-var CONFIG_DIR = path2.join(process.env.HOME || "", ".ae-cli");
-var CONFIG_FILE = path2.join(CONFIG_DIR, "config.json");
-var MCP_TOKENS_FILE = path2.join(CONFIG_DIR, "mcp-tokens.json");
-var FALLBACK_MCP_TOKEN_FILE = "/data/app/te_agent_ta/.ae-config/mcp-token.json";
-function ensureDir() {
-  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-function migrateFromFallback() {
-  if (!fs3.existsSync(FALLBACK_MCP_TOKEN_FILE) || fs3.existsSync(MCP_TOKENS_FILE)) {
-    return null;
+
+// 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 doMigrateFromFallback();
+  return homedir();
 }
-function forceMigrateFromFallback() {
-  if (!fs3.existsSync(FALLBACK_MCP_TOKEN_FILE)) {
-    return null;
+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 doMigrateFromFallback();
+  return paths;
 }
-function doMigrateFromFallback() {
-  try {
-    const fallbackData = safeReadJsonFile(FALLBACK_MCP_TOKEN_FILE);
-    const tokenStore = {};
-    if (fallbackData && typeof fallbackData === "object" && !Array.isArray(fallbackData)) {
-      const url = fallbackData.url;
-      const token = fallbackData["mcp-token"];
-      if (url && token) {
-        tokenStore[url] = token;
+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 {
     }
-    if (Object.keys(tokenStore).length > 0) {
-      ensureDir();
-      fs3.writeFileSync(MCP_TOKENS_FILE, JSON.stringify(tokenStore, null, 2));
-      return tokenStore;
-    }
-  } 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 {
-    const migratedTokens = migrateFromFallback();
     if (fs3.existsSync(CONFIG_FILE)) {
       const raw = safeReadJsonFile(CONFIG_FILE);
       if (raw.defaultHost && !raw.activeHost) {
@@ -142,23 +170,6 @@ function loadConfig() {
       }
       return raw;
     }
-    if (migratedTokens && Object.keys(migratedTokens).length > 0) {
-      const hosts = {};
-      for (const url of Object.keys(migratedTokens)) {
-        hosts[url] = { label: url };
-        process.stderr.write(`[ae-cli] Added host: ${url}
-`);
-      }
-      const activeHost = Object.keys(migratedTokens)[0];
-      process.stderr.write(`[ae-cli] Active host set to: ${activeHost}
-`);
-      process.stderr.write(`[ae-cli] MCP tokens migrated from ${FALLBACK_MCP_TOKEN_FILE}
-`);
-      logger.info(`MCP tokens migrated from fallback: activeHost=${activeHost}, hosts=${Object.keys(hosts).length}`);
-      const config = { activeHost, hosts };
-      saveConfig(config);
-      return config;
-    }
   } catch (err) {
     logger.error(`Error loading config: ${err.message}`);
     console.error(`Error loading config: ${err.message}`);
@@ -187,7 +198,8 @@ function saveConfig(config) {
 }
 function getActiveHost() {
   const config = loadConfig();
-  return config.activeHost;
+  if (config.activeHost) return config.activeHost;
+  return readSandboxMcpTokenEntry()?.url ?? "";
 }
 function setActiveHost(url) {
   const config = loadConfig();
@@ -199,61 +211,34 @@ function setActiveHost(url) {
 }
 function addHost(url, label) {
   const config = loadConfig();
+  assertUniqueHostLabel(config, label, url);
   config.hosts[url] = { label };
   if (!config.activeHost) {
     config.activeHost = url;
   }
   saveConfig(config);
 }
-function updateHostLabel(url, label) {
-  const config = loadConfig();
-  if (config.hosts[url]) {
-    config.hosts[url].label = label;
-    saveConfig(config);
-  }
-}
-function removeHost(url) {
-  const config = loadConfig();
-  delete config.hosts[url];
-  if (config.activeHost === url) {
-    const remaining = Object.keys(config.hosts);
-    config.activeHost = remaining.length > 0 ? remaining[0] : "";
+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]}`);
   }
-  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;
 }
-function extractHostname(fullUrl) {
-  try {
-    const u = new URL(fullUrl);
-    return u.host;
-  } catch {
-    return fullUrl;
-  }
-}
 
 export {
   logger,
   safeJsonParse,
   safeReadJsonFile,
-  forceMigrateFromFallback,
+  getSandboxRuntimeRoot,
+  getSandboxClusterInfoFilePath,
+  getFallbackMcpToken,
   loadConfig,
   saveConfig,
   getActiveHost,
   setActiveHost,
   addHost,
-  updateHostLabel,
-  removeHost,
-  listHosts,
-  getConfigDir,
-  extractHostname
+  getConfigDir
 };

package/dist/{chunk-OVHL4JAC.js → chunk-WCHI7725.js}

@@ -1,18 +1,18 @@
 import {
-  getToken
-} from "./chunk-47MTN54I.js";
+  getAnalysisMappingPathForClusterMode
+} from "./chunk-GSJGPNKK.js";
+import {
+  getToken,
+  loadMcpToken
+} from "./chunk-CAQYQA4R.js";
 import {
-  forceMigrateFromFallback,
   getActiveHost,
-  getConfigDir,
+  getFallbackMcpToken,
   logger,
-  safeJsonParse,
-  safeReadJsonFile
-} from "./chunk-DC66L5AM.js";
+  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();
@@ -37,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) {
@@ -54,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(/\/+$/, "");
@@ -95,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");
@@ -184,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,
@@ -251,7 +248,7 @@ function parseMcpResult(result) {
 export {
   registerMcpMappings,
   resolveMcpUrl,
-  loadMcpTokenStore,
+  getMcpToken,
   clearMcpToken,
   setMcpTokenManual,
   validateMcpToken,

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

@@ -2,17 +2,19 @@ import {
   httpDelete,
   httpGet,
   httpPost,
+  httpRequest,
   httpUpload,
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-MZW6NOVS.js";
-import "./chunk-47MTN54I.js";
-import "./chunk-DC66L5AM.js";
+} from "./chunk-LU7SXK4Q.js";
+import "./chunk-CAQYQA4R.js";
+import "./chunk-SRJIAOBN.js";
 export {
   httpDelete,
   httpGet,
   httpPost,
+  httpRequest,
   httpUpload,
   queryReportData,
   querySql,

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
+};