@thinkingai/ae-cli 6.0.38 → 6.0.39

package/dist/config-4VZNLBKF.js

@@ -0,0 +1,489 @@
+import {
+  MultiselectCancelled,
+  promptSingleSelect
+} from "./chunk-TUKQZTMI.js";
+import {
+  GLOBAL_QUERY_CONFIG_KEY,
+  getAnalysisMappingPathForClusterMode,
+  getClusterInfoFilePath,
+  isGlobalQueryModeEnabled,
+  setGlobalQueryModeEnabled
+} from "./chunk-NBPKWKRA.js";
+import {
+  printError,
+  printOutput
+} from "./chunk-YTG6Q75E.js";
+import "./chunk-Z3OXWCIA.js";
+import {
+  AE_TRIAL_URL,
+  missingAeHostHint
+} from "./chunk-YV52FB5G.js";
+import {
+  addHost,
+  listHosts,
+  loadConfig,
+  normalizeUrl,
+  removeHost,
+  resolveHostSelector,
+  setActiveHost,
+  updateHostLabel
+} from "./chunk-GJJA4CQZ.js";
+import "./chunk-JHENBQ5B.js";
+
+// src/commands/config.ts
+import * as readline2 from "readline";
+
+// src/commands/config-ui.ts
+import * as readline from "readline";
+async function runConfigUI() {
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    throw new Error("Interactive config requires a TTY.");
+  }
+  if (listHosts().length === 0) {
+    process.stderr.write("\n\x1B[1mNo AE environments configured.\x1B[0m\n\n");
+    process.stderr.write("Use the AE URL provided by your AgenticEngine administrator.\n");
+    process.stderr.write(`No AgenticEngine environment? Request a trial: ${AE_TRIAL_URL}
+
+`);
+    await promptAddEnvironment();
+    return;
+  }
+  while (true) {
+    const hosts = listHosts();
+    const items = [
+      ...hosts.map((host) => ({ type: "host", host })),
+      { type: "add" }
+    ];
+    const activeIndex = Math.max(0, hosts.findIndex((host) => host.active));
+    const result = await promptEnvironmentAction(items, activeIndex);
+    const item = items[result.index];
+    if (result.action === "quit") return;
+    if (result.action === "add" || item.type === "add") {
+      await promptAddEnvironment();
+      continue;
+    }
+    if (!item.host) continue;
+    if (result.action === "select") {
+      if (item.host.active) {
+        process.stderr.write(`
+Already active: \x1B[1m${item.host.label}\x1B[0m
+`);
+        return;
+      }
+      setActiveHost(item.host.url);
+      process.stderr.write(`
+\x1B[32m\u2713\x1B[0m Active environment: \x1B[1m${item.host.label}\x1B[0m ${item.host.url}
+`);
+      process.stderr.write(`  Authenticate if needed: ae-cli auth login --host ${item.host.url}
+`);
+      return;
+    }
+    if (result.action === "rename") {
+      await promptRenameEnvironment(item.host);
+      continue;
+    }
+    if (result.action === "remove") {
+      await promptRemoveEnvironment(item.host);
+    }
+  }
+}
+async function promptAddEnvironment() {
+  const urlInput = await ask("Host URL: ");
+  if (!urlInput) {
+    process.stderr.write("Cancelled.\n");
+    return;
+  }
+  const url = normalizeUrl(urlInput);
+  const existing = listHosts().find((host) => host.url === url);
+  if (existing) {
+    process.stderr.write(`\x1B[31m\u2717\x1B[0m Environment already configured as ${existing.label}: ${url}
+`);
+    return;
+  }
+  const defaultLabel = defaultLabelForUrl(url);
+  const labelInput = await ask(`Label [${defaultLabel}]: `);
+  const label = labelInput || defaultLabel;
+  try {
+    addHost(url, label);
+    const active = listHosts().find((host) => host.url === url)?.active;
+    process.stderr.write(
+      `
+\x1B[32m\u2713\x1B[0m Added${active ? " and activated" : ""}: \x1B[1m${label}\x1B[0m ${url}
+`
+    );
+    if (active) {
+      process.stderr.write(`  Authenticate if needed: ae-cli auth login --host ${url}
+`);
+    }
+  } catch (err) {
+    process.stderr.write(`\x1B[31m\u2717\x1B[0m ${err.message}
+`);
+  }
+}
+async function promptRenameEnvironment(host) {
+  const input = await ask(`New label [${host.label}]: `);
+  const label = input || host.label;
+  if (label === host.label) return;
+  try {
+    updateHostLabel(host.url, label);
+    process.stderr.write(`\x1B[32m\u2713\x1B[0m Renamed: ${host.label} \u2192 ${label}
+`);
+  } catch (err) {
+    process.stderr.write(`\x1B[31m\u2717\x1B[0m ${err.message}
+`);
+  }
+}
+async function promptRemoveEnvironment(host) {
+  const hosts = listHosts();
+  let replacement;
+  if (host.active && hosts.length > 1) {
+    try {
+      const replacementUrl = await promptSingleSelect({
+        title: `Select the environment to activate after removing ${host.label}:`,
+        items: hosts.filter((candidate) => candidate.url !== host.url).map((candidate) => ({
+          value: candidate.url,
+          label: `${candidate.label}  ${candidate.url}`
+        }))
+      });
+      replacement = hosts.find((candidate) => candidate.url === replacementUrl);
+    } catch (err) {
+      if (err instanceof MultiselectCancelled) return;
+      throw err;
+    }
+  }
+  const confirmed = await confirm(`Remove ${host.label} (${host.url})?`);
+  if (!confirmed) {
+    process.stderr.write("Cancelled.\n");
+    return;
+  }
+  if (replacement) setActiveHost(replacement.url);
+  removeHost(host.url);
+  process.stderr.write(`\x1B[32m\u2713\x1B[0m Removed: ${host.label}
+`);
+  if (replacement) {
+    process.stderr.write(`  Active environment: ${replacement.label} ${replacement.url}
+`);
+  } else if (listHosts().length === 0) {
+    process.stderr.write("  No AE environments remain.\n");
+  }
+}
+function promptEnvironmentAction(items, initialIndex) {
+  const stdin = process.stdin;
+  const stderr = process.stderr;
+  let cursor = initialIndex;
+  let renderCount = 0;
+  const lineCount = items.length + 4;
+  function render() {
+    if (renderCount > 0) stderr.write(`\x1B[${lineCount}A`);
+    const active = items.find((item) => item.host?.active)?.host;
+    stderr.write("\x1B[1mAE Environment Manager\x1B[0m\x1B[K\n");
+    stderr.write(`Active: ${active ? `${active.label}  ${active.url}` : "none"}\x1B[K
+`);
+    stderr.write("\u2191\u2193 select \xB7 Enter activate \xB7 e rename \xB7 d delete \xB7 a add \xB7 q quit\x1B[K\n");
+    stderr.write("\x1B[K\n");
+    items.forEach((item, index) => {
+      const pointer = index === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+      if (item.type === "add") {
+        stderr.write(`${pointer} \x1B[2m+ Add environment...\x1B[0m\x1B[K
+`);
+        return;
+      }
+      const host = item.host;
+      const marker = host.active ? "\x1B[32m\u25CF\x1B[0m" : "\x1B[2m\u25CB\x1B[0m";
+      const label = host.active ? `\x1B[1;32m${host.label}\x1B[0m` : `\x1B[1m${host.label}\x1B[0m`;
+      const badge = host.active ? "  \x1B[32m[active]\x1B[0m" : "";
+      stderr.write(`${pointer} ${marker} ${label}  ${host.url}${badge}\x1B[K
+`);
+    });
+    renderCount++;
+  }
+  return new Promise((resolve) => {
+    stderr.write("\n\x1B[?25l");
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    function finish(action) {
+      cleanup();
+      resolve({ action, index: cursor });
+    }
+    function onData(key) {
+      if (key === "\x1B[A" || key === "k") {
+        cursor = (cursor - 1 + items.length) % items.length;
+        render();
+      } else if (key === "\x1B[B" || key === "j") {
+        cursor = (cursor + 1) % items.length;
+        render();
+      } else if (key === "\r" || key === "\n") {
+        finish("select");
+      } else if ((key === "e" || key === "E") && items[cursor].type === "host") {
+        finish("rename");
+      } else if ((key === "d" || key === "D") && items[cursor].type === "host") {
+        finish("remove");
+      } else if (key === "a" || key === "A") {
+        finish("add");
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        finish("quit");
+      }
+    }
+    stdin.on("data", onData);
+    render();
+  });
+}
+function defaultLabelForUrl(url) {
+  try {
+    return new URL(url).hostname.split(".")[0] || url;
+  } catch {
+    return url;
+  }
+}
+async function ask(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+async function confirm(question) {
+  const answer = await ask(`${question} [y/N] `);
+  return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
+}
+
+// src/commands/config.ts
+function registerConfig(program) {
+  const configCmd = program.command("config").description("Manage AE host environments interactively or with subcommands").action(async () => {
+    if (!process.stdin.isTTY || !process.stderr.isTTY) {
+      failConfig(
+        "Interactive config requires a TTY.",
+        "Run: ae-cli config list, ae-cli config add <url> --label <label>, or ae-cli config --help"
+      );
+      return;
+    }
+    await runConfigUI();
+  });
+  configCmd.command("list").description("List configured AE environments").action(async () => {
+    await printConfigList(program);
+  });
+  configCmd.command("current").description("Show the active AE environment").action(async () => {
+    await printCurrentConfig(program);
+  });
+  configCmd.command("use <env>").description("Switch active AE environment by exact URL or unique label").action(async (env) => {
+    await useConfigEnv(program, env);
+  });
+  configCmd.command("add <url>").description("Add an AE environment").requiredOption("--label <label>", "Unique display label for this environment").option("--use", "Set the new environment as active").action(async (url, opts) => {
+    await addConfigEnv(program, url, opts);
+  });
+  configCmd.command("rename <env> <label>").description("Rename an AE environment selected by exact URL or unique label").action(async (env, label) => {
+    await renameConfigEnv(program, env, label);
+  });
+  configCmd.command("remove <env>").alias("delete").description("Remove an AE environment selected by exact URL or unique label").option("--yes", "Skip the deletion confirmation").action(async (env, opts) => {
+    await removeConfigEnv(program, env, Boolean(opts.yes || program.opts().yes));
+  });
+  configCmd.command("set-host <url>").description("Compatibility command: add or update an AE host and set it active").option("--label <label>", "Display label for this host (defaults to the host URL)").action(async (url, opts) => {
+    try {
+      const normalized = normalizeUrl(url);
+      const label = opts.label || normalized;
+      addHost(normalized, label);
+      setActiveHost(normalized);
+      await printOutput(
+        { activeHost: normalized, label: label.trim() },
+        program.opts().format || "json",
+        program.opts().jq
+      );
+    } catch (err) {
+      failConfig(err.message, "Run: ae-cli config list");
+    }
+  });
+  const clusterMode = configCmd.command("cluster-mode").description("Manage local multi-cluster analysis MCP mode").action(async () => {
+    await printClusterModeStatus(program);
+  });
+  clusterMode.command("status").description("Show local multi-cluster analysis MCP mode").action(async () => {
+    await printClusterModeStatus(program);
+  });
+  clusterMode.command("enable").description("Enable local multi-cluster analysis MCP mode").action(async () => {
+    setGlobalQueryModeEnabled(true);
+    await printClusterModeStatus(program);
+  });
+  clusterMode.command("disable").description("Disable local multi-cluster analysis MCP mode").action(async () => {
+    setGlobalQueryModeEnabled(false);
+    await printClusterModeStatus(program);
+  });
+}
+async function printClusterModeStatus(program) {
+  const enabled = isGlobalQueryModeEnabled();
+  await 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 };
+}
+async function printConfigList(program) {
+  const { activeHost, hosts } = readHostViews();
+  const activeLabel = hosts.find((host) => host.active)?.label || "";
+  await printOutput(
+    { activeHost, activeLabel, hosts },
+    program.opts().format || "json",
+    program.opts().jq
+  );
+}
+async function printCurrentConfig(program) {
+  const { activeHost, hosts } = readHostViews();
+  const current = hosts.find((h) => h.url === activeHost);
+  if (!current) {
+    failConfig("No active AE environment configured.", missingAeHostHint("Run ae-cli config list to inspect saved environments."));
+    return;
+  }
+  await printOutput({ activeHost: current.url, label: current.label }, program.opts().format || "json", program.opts().jq);
+}
+async function useConfigEnv(program, env) {
+  const target = resolveHostSelector(env);
+  if (target.status === "not-found") {
+    failHostResolution(env, target);
+    return;
+  }
+  if (target.status === "duplicate-label") {
+    failHostResolution(env, target);
+    return;
+  }
+  setActiveHost(target.host.url);
+  await printOutput({ activeHost: target.host.url, label: target.host.label }, program.opts().format || "json", program.opts().jq);
+}
+async function addConfigEnv(program, url, opts) {
+  const normalized = normalizeUrl(url);
+  const config = loadConfig();
+  if (config.hosts[normalized]) {
+    failConfig(
+      `AE environment is already configured: ${normalized}`,
+      `Run: ae-cli config rename ${quoteSelector(config.hosts[normalized].label)} <label> or ae-cli config use ${quoteSelector(config.hosts[normalized].label)}`
+    );
+    return;
+  }
+  try {
+    addHost(normalized, opts.label);
+    if (opts.use) setActiveHost(normalized);
+    const saved = loadConfig();
+    await printOutput(
+      {
+        url: normalized,
+        label: saved.hosts[normalized].label,
+        active: saved.activeHost === normalized
+      },
+      program.opts().format || "json",
+      program.opts().jq
+    );
+  } catch (err) {
+    failConfig(err.message, "Choose a non-empty, unique label and run the command again.");
+  }
+}
+async function renameConfigEnv(program, env, label) {
+  const target = resolveHostSelector(env);
+  if (target.status !== "found") {
+    failHostResolution(env, target);
+    return;
+  }
+  try {
+    updateHostLabel(target.host.url, label);
+    await printOutput(
+      { url: target.host.url, label: label.trim(), active: target.host.active },
+      program.opts().format || "json",
+      program.opts().jq
+    );
+  } catch (err) {
+    failConfig(err.message, "Choose a non-empty, unique label and run the command again.");
+  }
+}
+async function removeConfigEnv(program, env, skipConfirmation) {
+  const target = resolveHostSelector(env);
+  if (target.status !== "found") {
+    failHostResolution(env, target);
+    return;
+  }
+  const hosts = readHostViews().hosts;
+  if (target.host.active && hosts.length > 1) {
+    failConfig(
+      `Cannot remove the active AE environment: ${target.host.label}`,
+      "Switch first with: ae-cli config use <env>"
+    );
+    return;
+  }
+  if (!skipConfirmation) {
+    if (!process.stdin.isTTY) {
+      failConfig(
+        "Deletion confirmation requires a TTY.",
+        `Re-run with --yes: ae-cli config remove ${quoteSelector(env)} --yes`
+      );
+      return;
+    }
+    const confirmed = await confirm2(`Remove ${target.host.label} (${target.host.url})?`);
+    if (!confirmed) {
+      await printOutput(
+        { removed: false, url: target.host.url, label: target.host.label },
+        program.opts().format || "json",
+        program.opts().jq
+      );
+      return;
+    }
+  }
+  removeHost(target.host.url);
+  await printOutput(
+    {
+      removed: true,
+      url: target.host.url,
+      label: target.host.label,
+      activeHost: loadConfig().activeHost
+    },
+    program.opts().format || "json",
+    program.opts().jq
+  );
+}
+function failHostResolution(env, target) {
+  if (target.status === "duplicate-label") {
+    failConfig(
+      `Duplicate label: ${env}`,
+      `Rename duplicate labels first. Run: ae-cli config list \u2014 ${formatHostOptions(target.matches)}`
+    );
+    return;
+  }
+  failConfig(
+    `No AE environment matched: ${env}`,
+    target.hosts.length > 0 ? `Available environments: ${formatHostOptions(target.hosts)}` : missingAeHostHint()
+  );
+}
+function formatHostOptions(hosts) {
+  return hosts.map((h) => `${h.label} (${h.url})`).join(", ");
+}
+function quoteSelector(value) {
+  return JSON.stringify(value);
+}
+async function confirm2(message) {
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
+    });
+  });
+}
+function failConfig(message, hint) {
+  printError("config", message, hint);
+  process.exitCode = 1;
+}
+export {
+  registerConfig
+};