@thinkingai/ae-cli 6.0.41 → 6.0.44

package/dist/chunk-3FY3RJ26.js

@@ -1,293 +0,0 @@
-import {
-  logger
-} from "./chunk-JHENBQ5B.js";
-
-// src/core/json-utils.ts
-import fs from "fs";
-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 native;
-  }
-  if (Array.isArray(lossless) && Array.isArray(native)) {
-    for (let index = 0; index < lossless.length; index++) {
-      lossless[index] = normalizeParsedNumbers(lossless[index], native[index]);
-    }
-    return lossless;
-  }
-  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]);
-    }
-  }
-  return lossless;
-}
-function safeJsonParse(text) {
-  const lossless = jsonParser.parse(text);
-  return normalizeParsedNumbers(lossless, JSON.parse(text));
-}
-function safeReadJsonFile(filePath) {
-  const content = fs.readFileSync(filePath, "utf-8");
-  return safeJsonParse(content);
-}
-
-// src/core/url-utils.ts
-function normalizeUrl(url) {
-  if (!url) return url;
-  if (!url.startsWith("http://") && !url.startsWith("https://")) {
-    url = `https://${url}`;
-  }
-  return url.replace(/\/$/, "");
-}
-
-// src/core/config.ts
-import fs3 from "fs";
-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") {
-    return LINUX_SANDBOX_RUNTIME_ROOT;
-  }
-  return homedir();
-}
-function getSandboxRuntimeRoot() {
-  return process.env.SANDBOX_RUNTIME_ROOT || getDefaultSandboxRuntimeRoot();
-}
-function getSandboxAeConfigDir() {
-  return join(getSandboxRuntimeRoot(), ".ae-config");
-}
-function getSandboxCliTokenFilePath() {
-  return join(getSandboxAeConfigDir(), "cli-token.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 = path.join(process.env.HOME || "", ".ae-cli");
-var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
-function sandboxCliTokenCandidatePaths() {
-  const paths = [getSandboxCliTokenFilePath()];
-  const homeFallback = path.join(process.env.HOME || "", ".ae-config", "cli-token.json");
-  if (!paths.includes(homeFallback)) {
-    paths.push(homeFallback);
-  }
-  return paths;
-}
-function readSandboxCliTokenEntry() {
-  for (const file of sandboxCliTokenCandidatePaths()) {
-    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.token ?? data["cli-token"];
-        if (url && token) {
-          return { url, token };
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function forceMigrateFromFallback() {
-  const entry = readSandboxCliTokenEntry();
-  if (!entry) return null;
-  return { [entry.url]: entry.token };
-}
-function getFallbackCliToken(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 ensureDir() {
-  if (!fs3.existsSync(CONFIG_DIR)) fs3.mkdirSync(CONFIG_DIR, { recursive: true });
-}
-function dedupeNormalizedHosts(config) {
-  const hosts = {};
-  for (const [url, entry] of Object.entries(config.hosts)) {
-    const key = normalizeUrl(url);
-    if (!hosts[key]) {
-      hosts[key] = entry;
-    }
-  }
-  return {
-    activeHost: config.activeHost ? normalizeUrl(config.activeHost) : "",
-    hosts
-  };
-}
-function configNeedsNormalization(config) {
-  if (config.activeHost && normalizeUrl(config.activeHost) !== config.activeHost) return true;
-  const keys = Object.keys(config.hosts);
-  if (keys.some((url) => normalizeUrl(url) !== url)) return true;
-  return new Set(keys.map(normalizeUrl)).size !== keys.length;
-}
-function loadConfig() {
-  try {
-    if (fs3.existsSync(CONFIG_FILE)) {
-      const raw = safeReadJsonFile(CONFIG_FILE);
-      if (raw.defaultHost && !raw.activeHost) {
-        const migrated = dedupeNormalizedHosts(migrateConfig(raw));
-        saveConfig(migrated);
-        return migrated;
-      }
-      const rawConfig = raw;
-      if (configNeedsNormalization(rawConfig)) {
-        const config = dedupeNormalizedHosts(rawConfig);
-        saveConfig(config);
-        return config;
-      }
-      return rawConfig;
-    }
-  } 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 = normalizeUrl(key.startsWith("http") ? key : `https://${key}`);
-      hosts[url] = val;
-    }
-  }
-  const activeHost = normalizeUrl(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 sandboxHost = readSandboxCliTokenEntry()?.url;
-  if (sandboxHost) return sandboxHost;
-  const config = loadConfig();
-  return config.activeHost || "";
-}
-function setActiveHost(url) {
-  url = normalizeUrl(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) {
-  url = normalizeUrl(url);
-  label = normalizeLabel(label);
-  const config = loadConfig();
-  assertUniqueHostLabel(config, label, url);
-  config.hosts[url] = { label };
-  if (!config.activeHost) {
-    config.activeHost = url;
-  }
-  saveConfig(config);
-}
-function updateHostLabel(url, label) {
-  url = normalizeUrl(url);
-  label = normalizeLabel(label);
-  const config = loadConfig();
-  if (!config.hosts[url]) {
-    throw new Error(`Host is not configured: ${url}`);
-  }
-  assertUniqueHostLabel(config, label, url);
-  config.hosts[url].label = label;
-  saveConfig(config);
-}
-function normalizeLabel(label) {
-  const normalized = label.trim();
-  if (!normalized) {
-    throw new Error("Label cannot be empty.");
-  }
-  return normalized;
-}
-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 removeHost(url) {
-  url = normalizeUrl(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] : "";
-  }
-  saveConfig(config);
-}
-function listHosts() {
-  const config = loadConfig();
-  return Object.entries(config.hosts).map(([url, entry]) => ({
-    url,
-    label: entry.label,
-    active: url === config.activeHost
-  }));
-}
-function resolveHostSelector(env) {
-  const raw = env.trim();
-  const selector = raw.startsWith("http://") || raw.startsWith("https://") ? normalizeUrl(raw) : raw;
-  const hosts = listHosts();
-  const byUrl = hosts.find((host) => host.url === selector);
-  if (byUrl) return { status: "found", host: byUrl };
-  const byLabel = hosts.filter((host) => host.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 getConfigDir() {
-  return CONFIG_DIR;
-}
-
-export {
-  safeJsonParse,
-  safeReadJsonFile,
-  normalizeUrl,
-  getSandboxRuntimeRoot,
-  isAeSandboxRuntime,
-  getFallbackCliToken,
-  loadConfig,
-  saveConfig,
-  getActiveHost,
-  setActiveHost,
-  addHost,
-  updateHostLabel,
-  removeHost,
-  listHosts,
-  resolveHostSelector,
-  getConfigDir
-};

package/dist/chunk-S5NTSDBS.js

@@ -1,198 +0,0 @@
-import {
-  getToken,
-  load,
-  loadCliToken,
-  save
-} from "./chunk-ZQKDZXDO.js";
-import {
-  getActiveHost,
-  getConfigDir,
-  getFallbackCliToken,
-  listHosts,
-  normalizeUrl,
-  safeJsonParse,
-  safeReadJsonFile
-} from "./chunk-3FY3RJ26.js";
-import {
-  logger
-} from "./chunk-JHENBQ5B.js";
-
-// src/core/cli-token.ts
-import fs from "fs";
-import path from "path";
-var CLI_TOKEN_GENERATE_PATH = "/v1/ta/cli/token/generate";
-var _cliTokenCache = /* @__PURE__ */ new Map();
-var _renewedLocalDateByHost = /* @__PURE__ */ new Map();
-var _renewInFlightByHost = /* @__PURE__ */ new Map();
-function renewHostKey(hostUrl) {
-  return normalizeUrl(hostUrl);
-}
-function renewStateFilePath() {
-  return path.join(getConfigDir(), "cli-token-renew.json");
-}
-function localRenewDate(now = /* @__PURE__ */ new Date()) {
-  const y = now.getFullYear();
-  const m = String(now.getMonth() + 1).padStart(2, "0");
-  const d = String(now.getDate()).padStart(2, "0");
-  return `${y}-${m}-${d}`;
-}
-function loadRenewStore() {
-  try {
-    const file = renewStateFilePath();
-    if (!fs.existsSync(file)) return {};
-    const data = safeReadJsonFile(file);
-    if (!data || typeof data !== "object" || Array.isArray(data)) return {};
-    return data;
-  } catch {
-    return {};
-  }
-}
-function saveRenewStore(store) {
-  const dir = getConfigDir();
-  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-  const file = renewStateFilePath();
-  if (Object.keys(store).length === 0) {
-    try {
-      fs.unlinkSync(file);
-    } catch {
-    }
-    return;
-  }
-  fs.writeFileSync(file, JSON.stringify(store, null, 2), { encoding: "utf8" });
-  try {
-    fs.chmodSync(file, 384);
-  } catch {
-  }
-}
-function clearRenewState(hostUrl) {
-  if (hostUrl) {
-    const key = renewHostKey(hostUrl);
-    _renewedLocalDateByHost.delete(key);
-    _renewInFlightByHost.delete(key);
-    if (key !== hostUrl) {
-      _renewedLocalDateByHost.delete(hostUrl);
-      _renewInFlightByHost.delete(hostUrl);
-    }
-    const store = loadRenewStore();
-    let changed = false;
-    for (const k of /* @__PURE__ */ new Set([key, hostUrl])) {
-      if (store[k]) {
-        delete store[k];
-        changed = true;
-      }
-    }
-    if (changed) {
-      saveRenewStore(store);
-    }
-    return;
-  }
-  _renewedLocalDateByHost.clear();
-  _renewInFlightByHost.clear();
-  saveRenewStore({});
-}
-async function generateCliToken(hostUrl) {
-  const accessToken = await getToken(hostUrl);
-  const base = hostUrl.replace(/\/+$/, "");
-  const url = `${base}${CLI_TOKEN_GENERATE_PATH}`;
-  const resp = await fetch(url, {
-    method: "GET",
-    headers: {
-      "Authorization": `bearer ${accessToken}`
-    }
-  });
-  if (!resp.ok) {
-    throw new Error(`CLI token generate HTTP error: ${resp.status} ${resp.statusText}`);
-  }
-  const data = safeJsonParse(await resp.text());
-  if (data.return_code !== 0) {
-    throw new Error(`CLI token generate error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
-  }
-  const cliToken = data.data?.userSecret;
-  if (!cliToken) {
-    throw new Error("CLI token generate error: empty userSecret in response");
-  }
-  return cliToken;
-}
-function persistCliTokenIfPossible(hostUrl, cliToken) {
-  const existing = load(hostUrl);
-  if (!existing) {
-    logger.info(`cli-token: no secure-store session for ${hostUrl}, keeping token in-process only`);
-    return;
-  }
-  save(hostUrl, { ...existing, cliToken });
-}
-function clearPersistedCliToken(hostUrl) {
-  const existing = load(hostUrl);
-  if (existing?.cliToken) {
-    save(hostUrl, { ...existing, cliToken: void 0 });
-  }
-}
-function peekCliToken(hostOverride) {
-  const hostUrl = hostOverride || getActiveHost();
-  if (!hostUrl) return void 0;
-  return _cliTokenCache.get(hostUrl) || loadCliToken(hostUrl) || getFallbackCliToken(hostUrl) || void 0;
-}
-async function getCliToken(hostOverride) {
-  const hostUrl = hostOverride || getActiveHost();
-  let token = _cliTokenCache.get(hostUrl);
-  if (!token) {
-    const storedToken = loadCliToken(hostUrl);
-    if (storedToken) {
-      _cliTokenCache.set(hostUrl, storedToken);
-      logger.info(`Using persisted CLI token (secure-store) for ${hostUrl}`);
-      token = storedToken;
-    }
-  }
-  if (!token) {
-    const fallbackToken = getFallbackCliToken(hostUrl);
-    if (fallbackToken) {
-      _cliTokenCache.set(hostUrl, fallbackToken);
-      logger.info(`Using sandbox-provisioned CLI token (fallback file) for ${hostUrl}`);
-      token = fallbackToken;
-    }
-  }
-  if (!token) {
-    token = await mintCliToken(hostUrl);
-  }
-  return token;
-}
-async function mintCliToken(hostUrl) {
-  logger.info(`Generating CLI token for ${hostUrl}`);
-  const cliToken = await generateCliToken(hostUrl);
-  _cliTokenCache.set(hostUrl, cliToken);
-  persistCliTokenIfPossible(hostUrl, cliToken);
-  logger.info(`CLI token generated, cached, and persisted for ${hostUrl}`);
-  return cliToken;
-}
-function clearCliToken(hostUrl) {
-  if (hostUrl) {
-    _cliTokenCache.delete(hostUrl);
-    clearPersistedCliToken(hostUrl);
-    clearRenewState(hostUrl);
-    return;
-  }
-  _cliTokenCache.clear();
-  clearRenewState();
-  for (const { url } of listHosts()) {
-    clearPersistedCliToken(url);
-  }
-}
-function setCliTokenManual(token, hostUrl) {
-  _cliTokenCache.set(hostUrl, token);
-  persistCliTokenIfPossible(hostUrl, token);
-  logger.info(`CLI token set for ${hostUrl}`);
-}
-function _resetRenewMemoryForTest() {
-  _renewedLocalDateByHost.clear();
-  _renewInFlightByHost.clear();
-}
-
-export {
-  localRenewDate,
-  peekCliToken,
-  getCliToken,
-  mintCliToken,
-  clearCliToken,
-  setCliTokenManual,
-  _resetRenewMemoryForTest
-};