@thinkingai/ae-cli 1.0.24 → 1.0.28

package/dist/chunk-AD5V3ZPJ.js

@@ -0,0 +1,217 @@
+import {
+  TeAgentCredentialsError,
+  tryLoadTeAgentSandboxCredentials
+} from "./chunk-KAEZTSXN.js";
+import {
+  getActiveHost
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/te-agent-client.ts
+var TeAgentApiError = class extends Error {
+  constructor(message, status, code, body) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.body = body;
+    this.name = "TeAgentApiError";
+  }
+  status;
+  code;
+  body;
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var UPLOAD_TIMEOUT_MS = 12e4;
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      throw new TeAgentApiError(`Request timed out (${timeoutMs}ms): ${url}`, 0, "TIMEOUT");
+    }
+    throw new TeAgentApiError(`Network request failed: ${err?.message ?? err}`, 0, "NETWORK_ERROR");
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function teClaudeBaseFromActiveHost() {
+  const override = process.env.TE_CLAUDE_BASE_URL;
+  if (override) return override.replace(/\/+$/, "");
+  const h = getActiveHost();
+  if (!h) return void 0;
+  const base = h.replace(/\/+$/, "");
+  const bp = process.env.TE_CLAUDE_BASE_PATH || "/agent";
+  return base.endsWith(bp) ? base : base + bp;
+}
+async function signRequest(method, path, rawBody) {
+  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
+    const headers2 = {
+      "X-Sandbox-Id": sandboxCred.sandboxId,
+      "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
+    };
+    if (method === "POST" || method === "PATCH") {
+      headers2["Content-Type"] = "application/json";
+    }
+    return {
+      url: `${sandboxCred.url.replace(/\/$/, "")}${path}`,
+      headers: headers2,
+      rawBody
+    };
+  }
+  const { getToken } = await import("./auth-H2376DEF.js");
+  const baseUrl = sandboxCred?.url || teClaudeBaseFromActiveHost();
+  if (!baseUrl) {
+    throw new TeAgentCredentialsError(
+      "Cannot determine the te-claude service URL",
+      "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
+    );
+  }
+  const accessToken = await getToken(getActiveHost() || baseUrl);
+  const headers = {
+    "Authorization": `bearer ${accessToken}`
+  };
+  if (method === "POST" || method === "PATCH") {
+    headers["Content-Type"] = "application/json";
+  }
+  return {
+    url: `${baseUrl.replace(/\/$/, "")}${path}`,
+    headers,
+    rawBody
+  };
+}
+async function parseResponse(response, defaultErrorPrefix) {
+  const text = await response.text();
+  let parsed = void 0;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new TeAgentApiError(
+        `Session expired or unauthorized. Please run: ae-cli auth login`,
+        response.status,
+        "auth_expired",
+        parsed
+      );
+    }
+    const message = typeof parsed === "object" && parsed && typeof parsed.error === "string" ? parsed.error : `${defaultErrorPrefix} ${response.status}`;
+    const code = typeof parsed === "object" && parsed && typeof parsed.code === "string" ? parsed.code : void 0;
+    throw new TeAgentApiError(message, response.status, code, parsed);
+  }
+  return parsed;
+}
+async function postToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = await signRequest("POST", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "POST",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function getFromMainApp(path) {
+  const signed = await signRequest("GET", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "GET",
+    headers: signed.headers
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function getSandboxModels(currentModelId) {
+  const qs = currentModelId ? `?current=${encodeURIComponent(currentModelId)}` : "";
+  const data = await getFromMainApp(`/api/sandbox/models${qs}`);
+  return Array.isArray(data?.models) ? data.models : [];
+}
+async function postSandboxModelSelection(args) {
+  return postToMainApp("/api/sandbox/models/select", args);
+}
+async function getSandboxSyncPullCandidates(args) {
+  const qs = new URLSearchParams({
+    workspacePath: args.workspacePath,
+    kind: args.kind
+  });
+  return getFromMainApp(
+    `/api/sandbox/sync/pull/candidates?${qs.toString()}`
+  );
+}
+async function postSandboxSyncPull(args) {
+  return postToMainApp("/api/sandbox/sync/pull", {
+    workspacePath: args.workspacePath,
+    kind: args.kind,
+    skills: args.skills,
+    mcp: args.mcp,
+    mode: "merge",
+    ifUnmodifiedSince: args.ifUnmodifiedSince
+  });
+}
+async function deleteFromMainApp(path) {
+  const signed = await signRequest("DELETE", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "DELETE",
+    headers: signed.headers
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function patchToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = await signRequest("PATCH", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "PATCH",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "Main app returned");
+}
+async function uploadToMainApp(path, formData) {
+  const sandboxCred = tryLoadTeAgentSandboxCredentials();
+  let baseUrl;
+  let authHeaders;
+  if (sandboxCred && sandboxCred.sandboxId && sandboxCred.sandboxSecretKey) {
+    baseUrl = sandboxCred.url.replace(/\/$/, "");
+    authHeaders = {
+      "X-Sandbox-Id": sandboxCred.sandboxId,
+      "X-Sandbox-Secret-Key": sandboxCred.sandboxSecretKey
+    };
+  } else {
+    const { getToken } = await import("./auth-H2376DEF.js");
+    baseUrl = (sandboxCred?.url || teClaudeBaseFromActiveHost() || "").replace(/\/$/, "");
+    if (!baseUrl) {
+      throw new TeAgentCredentialsError(
+        "Cannot determine the te-claude service URL",
+        "Run ae-cli config set-host <url> to configure the service URL, or execute inside a te-agent sandbox"
+      );
+    }
+    const accessToken = await getToken(getActiveHost() || baseUrl);
+    authHeaders = { "Authorization": `bearer ${accessToken}` };
+  }
+  const response = await fetchWithTimeout(
+    `${baseUrl}${path}`,
+    {
+      method: "POST",
+      headers: authHeaders,
+      body: formData
+    },
+    UPLOAD_TIMEOUT_MS
+  );
+  return parseResponse(response, "Upload failed");
+}
+
+export {
+  TeAgentApiError,
+  postToMainApp,
+  getFromMainApp,
+  getSandboxModels,
+  postSandboxModelSelection,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  deleteFromMainApp,
+  patchToMainApp,
+  uploadToMainApp
+};

package/dist/chunk-CAQYQA4R.js

@@ -0,0 +1,399 @@
+import {
+  getActiveHost,
+  getConfigDir,
+  logger,
+  safeJsonParse,
+  safeReadJsonFile
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/auth.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/secure-store.ts
+import crypto from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { execFileSync } from "child_process";
+var STORE_DIR_SUFFIX = "secure-tokens";
+var SCRYPT_SALT = Buffer.from("ae-cli-secure-store-v1");
+var SCRYPT_N = 16384;
+var SCRYPT_R = 8;
+var SCRYPT_P = 1;
+var KEY_LEN = 32;
+var NONCE_LEN = 12;
+var REFRESH_TOKEN_PATH = "/v1/oauth/refreshForToken";
+function getMachineId() {
+  if (process.platform === "darwin") {
+    try {
+      const out = execFileSync(
+        "ioreg",
+        ["-rd1", "-c", "IOPlatformExpertDevice"],
+        { encoding: "utf8", timeout: 3e3 }
+      );
+      const m = out.match(/IOPlatformUUID.*?=.*?"([0-9A-F-]{36})"/i);
+      if (m?.[1]) return `darwin:${m[1]}`;
+    } catch {
+    }
+  }
+  if (process.platform === "linux") {
+    for (const p of ["/etc/machine-id", "/var/lib/dbus/machine-id"]) {
+      try {
+        const id = fs.readFileSync(p, "utf8").trim();
+        if (id) return `linux:${id}`;
+      } catch {
+      }
+    }
+  }
+  if (process.platform === "win32") {
+    try {
+      const out = execFileSync(
+        "reg",
+        ["query", "HKLM\\SOFTWARE\\Microsoft\\Cryptography", "/v", "MachineGuid"],
+        { encoding: "utf8", timeout: 3e3 }
+      );
+      const m = out.match(/MachineGuid\s+REG_SZ\s+([0-9a-f-]+)/i);
+      if (m?.[1]) return `win32:${m[1]}`;
+    } catch {
+    }
+  }
+  const fallback = `${os.homedir()}|${os.hostname()}|${os.platform()}`;
+  logger.warn("secure-store: using fallback machine-id (HOME+hostname+platform)");
+  return `fallback:${fallback}`;
+}
+var _cachedMachineId;
+function getCachedMachineId() {
+  if (!_cachedMachineId) _cachedMachineId = getMachineId();
+  return _cachedMachineId;
+}
+function deriveKey(machineId) {
+  return crypto.scryptSync(machineId, SCRYPT_SALT, KEY_LEN, {
+    N: SCRYPT_N,
+    r: SCRYPT_R,
+    p: SCRYPT_P
+  });
+}
+var _cachedKey;
+function getKey() {
+  if (!_cachedKey) _cachedKey = deriveKey(getCachedMachineId());
+  return _cachedKey;
+}
+function encrypt(plaintext) {
+  const key = getKey();
+  const nonce = crypto.randomBytes(NONCE_LEN);
+  const cipher = crypto.createCipheriv("aes-256-gcm", key, nonce);
+  const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    nonce: nonce.toString("hex"),
+    tag: tag.toString("hex"),
+    data: encrypted.toString("hex")
+  };
+}
+function decrypt(blob) {
+  const key = getKey();
+  const nonce = Buffer.from(blob.nonce, "hex");
+  const tag = Buffer.from(blob.tag, "hex");
+  const data = Buffer.from(blob.data, "hex");
+  const decipher = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([decipher.update(data), decipher.final()]);
+  return decrypted.toString("utf8");
+}
+function storeDir() {
+  return path.join(getConfigDir(), STORE_DIR_SUFFIX);
+}
+function tokenFilePath(host) {
+  const safe = host.replace(/^https?:\/\//, "").replace(/[^a-zA-Z0-9._-]/g, "_");
+  return path.join(storeDir(), `${safe}.enc.json`);
+}
+function ensureStoreDir() {
+  const dir = storeDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+    try {
+      fs.chmodSync(dir, 448);
+    } catch {
+    }
+  }
+}
+function save(host, payload) {
+  ensureStoreDir();
+  const plaintext = JSON.stringify(payload);
+  const blob = encrypt(plaintext);
+  const filePath = tokenFilePath(host);
+  fs.writeFileSync(filePath, JSON.stringify(blob, null, 2), { encoding: "utf8" });
+  try {
+    fs.chmodSync(filePath, 384);
+  } catch {
+  }
+  logger.info(`secure-store: token saved for ${host}`);
+}
+function load(host) {
+  const filePath = tokenFilePath(host);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    const raw = fs.readFileSync(filePath, "utf8");
+    const blob = safeJsonParse(raw);
+    if (!blob?.nonce || !blob?.tag || !blob?.data) {
+      logger.warn(`secure-store: malformed blob for ${host}`);
+      return null;
+    }
+    const plaintext = decrypt(blob);
+    return JSON.parse(plaintext);
+  } catch (e) {
+    logger.error(`secure-store: decrypt failed for ${host}: ${e.message}`);
+    return null;
+  }
+}
+function clear(host) {
+  const filePath = tokenFilePath(host);
+  if (fs.existsSync(filePath)) {
+    fs.rmSync(filePath);
+    logger.info(`secure-store: token cleared for ${host}`);
+  }
+}
+async function getValidAccessToken(host) {
+  const payload = load(host);
+  if (!payload) {
+    throw new SecureStoreAuthError(
+      `No stored token for ${host}. Please run: ae-cli auth login`
+    );
+  }
+  const expiresAt = new Date(payload.accessExpiresAt).getTime();
+  const now = Date.now();
+  const needsRefresh = expiresAt - now < 6e4;
+  if (!needsRefresh) {
+    return payload.accessToken;
+  }
+  if (payload.refreshToken) {
+    logger.info(`secure-store: access token past local expiry for ${host}, refreshing\u2026`);
+    const refreshed = await doRefresh(host, payload.refreshToken);
+    save(host, { ...refreshed, mcpToken: payload.mcpToken });
+    logger.info(`secure-store: token refreshed for ${host}`);
+    return refreshed.accessToken;
+  }
+  logger.info(`secure-store: ${host} past static local expiry, no refresh token \u2014 returning stored token, server validates (lazy)`);
+  return payload.accessToken;
+}
+function loadMcpToken(host) {
+  return load(host)?.mcpToken ?? null;
+}
+async function doRefresh(host, refreshToken) {
+  const base = host.replace(/\/+$/, "");
+  const url = `${base}${REFRESH_TOKEN_PATH}`;
+  let resp;
+  try {
+    resp = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ refreshToken })
+    });
+  } catch (e) {
+    throw new SecureStoreAuthError(
+      `Token refresh network error for ${host}: ${e.message}. Please run: ae-cli auth login`
+    );
+  }
+  if (!resp.ok) {
+    throw new SecureStoreAuthError(
+      `Token refresh failed (HTTP ${resp.status}) for ${host}. Please run: ae-cli auth login`
+    );
+  }
+  let body;
+  try {
+    body = safeJsonParse(await resp.text());
+  } catch {
+    throw new SecureStoreAuthError(
+      `Token refresh returned invalid JSON for ${host}. Please run: ae-cli auth login`
+    );
+  }
+  if (body.return_code !== 0) {
+    throw new SecureStoreAuthError(
+      `Token refresh error (${body.return_code}: ${body.return_message ?? "unknown"}) for ${host}. Please run: ae-cli auth login`
+    );
+  }
+  const d = body.data;
+  const newAccess = d?.accessToken ?? d?.access_token ?? "";
+  const newRefresh = d?.refreshToken ?? d?.refresh_token ?? refreshToken;
+  const expiresIn = d?.expiresIn ?? d?.expires_in ?? 72e3;
+  if (!newAccess) {
+    throw new SecureStoreAuthError(
+      `Token refresh returned empty accessToken for ${host}. Please run: ae-cli auth login`
+    );
+  }
+  return {
+    accessToken: newAccess,
+    refreshToken: newRefresh,
+    accessExpiresAt: new Date(Date.now() + expiresIn * 1e3).toISOString()
+  };
+}
+var SecureStoreAuthError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SecureStoreAuthError";
+  }
+};
+
+// 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();
+}
+async function validateToken(token, hostUrl) {
+  const url = `${hostUrl}/v1/oauth/checkToken`;
+  try {
+    const resp = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({ accessToken: token }).toString()
+    });
+    const respJson = safeJsonParse(await resp.text());
+    return respJson?.return_code === 0;
+  } catch {
+    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);
+      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();
+  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 setTokenManual(token, hostUrl) {
+  saveToken(token, hostUrl);
+}
+function getAuthStatus(hostUrl) {
+  if (process.env.TE_TOKEN) {
+    return { authenticated: true, host: hostUrl, source: "env:TE_TOKEN" };
+  }
+  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 };
+}
+async function getToken(hostUrl) {
+  if (!hostUrl) {
+    throw new Error(
+      `No AE host configured.
+Run: ae-cli config set-host <url>`
+    );
+  }
+  if (process.env.TE_TOKEN) {
+    logger.info("Using token from env:TE_TOKEN");
+    return process.env.TE_TOKEN;
+  }
+  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}`);
+    return secureToken;
+  } catch (e) {
+    if (e instanceof SecureStoreAuthError) {
+      logger.info(`secure-store: ${e.message}`);
+    } else {
+      logger.warn(`secure-store unexpected error: ${e.message}`);
+    }
+  }
+  throw new Error(
+    `Cannot obtain token for ${hostUrl}.
+Options:
+  1. ae-cli auth login   (device code flow, cross-platform)
+  2. ae-cli auth set-token <token>
+  3. export TE_TOKEN=<token>  (CI/headless)`
+  );
+}
+
+export {
+  save,
+  load,
+  clear,
+  loadMcpToken,
+  SecureStoreAuthError,
+  resolveHost,
+  validateToken,
+  loadToken,
+  saveToken,
+  clearToken,
+  setTokenManual,
+  getAuthStatus,
+  getToken
+};

package/dist/{chunk-JJCRURTR.js → chunk-CLJF7MQA.js}

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

package/dist/chunk-GSJGPNKK.js

@@ -0,0 +1,49 @@
+import {
+  getSandboxClusterInfoFilePath,
+  logger,
+  safeReadJsonFile
+} from "./chunk-SRJIAOBN.js";
+
+// src/core/cluster-info.ts
+import fs from "fs";
+import path from "path";
+var GLOBAL_QUERY_CONFIG_KEY = "sw_cfg_enable_global_query";
+var CLUSTER_INFO_FILE_ENV = "AE_CLUSTER_INFO_FILE";
+function getClusterInfoFilePath() {
+  return process.env[CLUSTER_INFO_FILE_ENV] || getSandboxClusterInfoFilePath();
+}
+function loadClusterInfo() {
+  const file = getClusterInfoFilePath();
+  try {
+    if (!fs.existsSync(file)) {
+      return {};
+    }
+    const raw = safeReadJsonFile(file);
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch (err) {
+    logger.warn(`Failed to load cluster info from ${file}: ${err.message}`);
+    return {};
+  }
+}
+function isGlobalQueryModeEnabled() {
+  return loadClusterInfo()[GLOBAL_QUERY_CONFIG_KEY] === true;
+}
+function setGlobalQueryModeEnabled(enabled) {
+  const file = getClusterInfoFilePath();
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true });
+  const next = { [GLOBAL_QUERY_CONFIG_KEY]: enabled };
+  fs.writeFileSync(file, JSON.stringify(next, null, 2));
+  return next;
+}
+function getAnalysisMappingPathForClusterMode(enabled = isGlobalQueryModeEnabled()) {
+  return enabled ? "analysis-global" : "analysis";
+}
+
+export {
+  GLOBAL_QUERY_CONFIG_KEY,
+  getClusterInfoFilePath,
+  isGlobalQueryModeEnabled,
+  setGlobalQueryModeEnabled,
+  getAnalysisMappingPathForClusterMode
+};