@thinkingai/ae-cli 1.0.1

package/dist/config-Q7J3Z7Z2.js

@@ -0,0 +1,242 @@
+import {
+  getAuthStatus,
+  getToken
+} from "./chunk-RJNLN3KQ.js";
+import {
+  addHost,
+  listHosts,
+  removeHost,
+  setActiveHost,
+  updateHostLabel
+} from "./chunk-OVQOK35G.js";
+
+// src/commands/config.ts
+import * as readline from "readline";
+function registerConfig(program) {
+  program.command("config").description("Interactive TE host configuration manager").action(async () => {
+    await runConfigUI(program);
+  });
+}
+async function runConfigUI(program) {
+  const hosts = listHosts();
+  if (hosts.length === 0) {
+    process.stderr.write("\x1B[1m[ae-cli] No TE hosts configured. Let's add one.\x1B[0m\n\n");
+    const newHost = await promptNewHost();
+    if (!newHost) {
+      process.stderr.write("Cancelled.\n");
+      return;
+    }
+    addHost(newHost.url, newHost.label);
+    setActiveHost(newHost.url);
+    process.stderr.write(`
+\x1B[32m\u2713\x1B[0m Added and activated: \x1B[1m${newHost.label}\x1B[0m ${newHost.url}
+`);
+    await ensureAuth(newHost.url);
+    return;
+  }
+  await hostManagerLoop(program);
+}
+async function hostManagerLoop(program) {
+  while (true) {
+    const hosts = listHosts();
+    const items = hosts.map((h) => ({
+      display: formatHostLine(h),
+      type: "host",
+      url: h.url,
+      label: h.label,
+      active: h.active
+    }));
+    items.push({ display: "\x1B[2m  + Add new host...\x1B[0m", type: "add", url: "", label: "", active: false });
+    const activeIdx = items.findIndex((i) => i.active);
+    process.stderr.write("\n\x1B[1mTE Host Manager\x1B[0m  (\u2191\u2193 select \xB7 Enter switch \xB7 e edit label \xB7 d delete \xB7 a add \xB7 q quit)\n\n");
+    const result = await interactiveHostSelect(items, activeIdx >= 0 ? activeIdx : 0);
+    if (result.action === "quit" || result.action === "cancel") {
+      break;
+    }
+    const item = items[result.index];
+    if (result.action === "select") {
+      if (item.type === "add") {
+        await handleAddHost();
+      } else {
+        setActiveHost(item.url);
+        process.stderr.write(`
+\x1B[32m\u2713\x1B[0m Switched to: \x1B[1m${item.label}\x1B[0m ${item.url}
+`);
+        await ensureAuth(item.url);
+        break;
+      }
+    } else if (result.action === "edit" && item.type === "host") {
+      await handleEditLabel(item.url, item.label);
+    } else if (result.action === "delete" && item.type === "host") {
+      await handleDeleteHost(item.url, item.label, item.active);
+    } else if (result.action === "add") {
+      await handleAddHost();
+    }
+  }
+}
+function formatHostLine(h) {
+  const marker = h.active ? "\x1B[32m\u25CF\x1B[0m" : "\x1B[2m\u25CB\x1B[0m";
+  const labelText = h.active ? `\x1B[1;32m${h.label}\x1B[0m` : `\x1B[1m${h.label}\x1B[0m`;
+  const authInfo = getAuthStatus(h.url);
+  const authBadge = authInfo.authenticated ? `\x1B[32m\u2713\x1B[0m` : `\x1B[31m\u2717\x1B[0m`;
+  return `${marker} ${labelText}  ${h.url}  ${authBadge}`;
+}
+async function handleAddHost() {
+  const newHost = await promptNewHost();
+  if (!newHost) {
+    process.stderr.write("Cancelled.\n");
+    return;
+  }
+  addHost(newHost.url, newHost.label);
+  setActiveHost(newHost.url);
+  process.stderr.write(`
+\x1B[32m\u2713\x1B[0m Added and activated: \x1B[1m${newHost.label}\x1B[0m ${newHost.url}
+`);
+  await ensureAuth(newHost.url);
+}
+async function handleEditLabel(url, currentLabel) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const newLabel = await new Promise(
+    (resolve) => rl.question(`
+New label [${currentLabel}]: `, (a) => {
+      rl.close();
+      resolve(a.trim() || currentLabel);
+    })
+  );
+  if (newLabel !== currentLabel) {
+    updateHostLabel(url, newLabel);
+    process.stderr.write(`\x1B[32m\u2713\x1B[0m Label updated: ${newLabel}
+`);
+  }
+}
+async function handleDeleteHost(url, label, isActive) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise(
+    (resolve) => rl.question(`
+Delete \x1B[1m${label}\x1B[0m (${url})? [y/N]: `, (a) => {
+      rl.close();
+      resolve(a.trim().toLowerCase());
+    })
+  );
+  if (answer === "y" || answer === "yes") {
+    removeHost(url);
+    process.stderr.write(`\x1B[32m\u2713\x1B[0m Deleted: ${label}
+`);
+    if (isActive) {
+      const remaining = listHosts();
+      if (remaining.length > 0) {
+        process.stderr.write(`  Active host switched to: ${remaining[0].label}
+`);
+      } else {
+        process.stderr.write("  No hosts remaining. Run ae-cli config to add one.\n");
+      }
+    }
+  }
+}
+async function ensureAuth(hostUrl) {
+  const status = getAuthStatus(hostUrl);
+  if (status.authenticated) {
+    process.stderr.write(`\x1B[32m\u2713\x1B[0m Token valid for ${hostUrl}
+`);
+    return;
+  }
+  process.stderr.write(`
+\x1B[33m!\x1B[0m No valid token for ${hostUrl}. Starting login...
+`);
+  try {
+    await getToken(hostUrl);
+    process.stderr.write(`\x1B[32m\u2713\x1B[0m Authenticated to ${hostUrl}
+`);
+  } catch (err) {
+    process.stderr.write(`\x1B[31m\u2717\x1B[0m Auth failed: ${err.message}
+`);
+    process.stderr.write(`  You can set token manually: ae-cli auth set-token <token>
+`);
+  }
+}
+async function promptNewHost() {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const ask = (q) => new Promise((resolve) => rl.question(q, (a) => resolve(a.trim())));
+  const url = await ask("TE host URL (e.g., https://ta.thinkingdata.cn): ");
+  if (!url) {
+    rl.close();
+    return null;
+  }
+  const label = await ask("Label: ");
+  rl.close();
+  if (!label) return null;
+  return { url: normalizeUrl(url), label };
+}
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+function interactiveHostSelect(items, initialIndex) {
+  return new Promise((resolve) => {
+    let cursor = initialIndex;
+    const stdin = process.stdin;
+    const stderr = process.stderr;
+    let renderCount = 0;
+    stderr.write("\x1B[?25l");
+    function render() {
+      if (renderCount > 0) {
+        stderr.write(`\x1B[${items.length}A`);
+      }
+      for (let i = 0; i < items.length; i++) {
+        const pointer = i === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+        stderr.write(`${pointer} ${items[i].display}\x1B[K
+`);
+      }
+      renderCount++;
+    }
+    render();
+    if (!stdin.isTTY) {
+      stderr.write("\x1B[?25h");
+      resolve({ action: "select", index: initialIndex });
+      return;
+    }
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdin.setEncoding("utf8");
+    function cleanup() {
+      stdin.setRawMode(false);
+      stdin.pause();
+      stdin.removeListener("data", onData);
+      stderr.write("\x1B[?25h");
+    }
+    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") {
+        cleanup();
+        resolve({ action: "select", index: cursor });
+      } else if (key === "e" || key === "E") {
+        if (items[cursor].type === "host") {
+          cleanup();
+          resolve({ action: "edit", index: cursor });
+        }
+      } else if (key === "d" || key === "D") {
+        if (items[cursor].type === "host") {
+          cleanup();
+          resolve({ action: "delete", index: cursor });
+        }
+      } else if (key === "a" || key === "A") {
+        cleanup();
+        resolve({ action: "add", index: cursor });
+      } else if (key === "q" || key === "Q" || key === "\x1B" || key === "") {
+        cleanup();
+        resolve({ action: "quit", index: cursor });
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+export {
+  registerConfig
+};

package/dist/index.js

@@ -0,0 +1,277 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  getActiveHost
+} from "./chunk-OVQOK35G.js";
+
+// src/index.ts
+import { Command as CommanderCommand } from "commander";
+import { createRequire } from "module";
+
+// src/framework/runner.ts
+import * as readline from "readline";
+async function runCommand(cmd, opts, globalOpts) {
+  try {
+    const ctx = createRuntimeContext(cmd, opts, globalOpts);
+    for (const flag of cmd.flags) {
+      if (flag.required) {
+        const val = opts[camelCase(flag.name)];
+        if (val === void 0 || val === null || val === "") {
+          printError("validation", `Missing required flag: --${flag.name}`, `Usage: ae-cli ${cmd.service} ${cmd.command} --${flag.name} <value>`);
+          process.exit(1);
+        }
+      }
+    }
+    if (cmd.validate) {
+      cmd.validate(ctx);
+    }
+    if (globalOpts.dryRun) {
+      if (cmd.dryRun) {
+        const dryResult = cmd.dryRun(ctx);
+        printOutput(dryResult, globalOpts.format, globalOpts.jq);
+      } else {
+        printOutput({ message: "No dry-run implementation for this command" }, globalOpts.format);
+      }
+      return;
+    }
+    if (cmd.risk === "write" && !globalOpts.yes) {
+      const confirmed = await confirm(`This is a write operation (${cmd.service} ${cmd.command}). Continue?`);
+      if (!confirmed) {
+        process.stderr.write("Aborted.\n");
+        process.exit(0);
+      }
+    }
+    const result = await cmd.execute(ctx);
+    ctx.out(result);
+  } catch (err) {
+    const message = err.message || String(err);
+    if (message.includes("token") || message.includes("auth") || message.includes("401") || message.includes("403")) {
+      printError("auth", message, "Run: ae-cli auth login");
+    } else if (message.includes("TE API error")) {
+      printError("api", message);
+    } else {
+      printError("api", message);
+    }
+    process.exit(1);
+  }
+}
+function createRuntimeContext(cmd, opts, globalOpts) {
+  let _clientModule = null;
+  async function getClient() {
+    if (!_clientModule) {
+      _clientModule = await import("./client-5QSQBBDB.js");
+    }
+    return _clientModule;
+  }
+  const ctx = {
+    str(name) {
+      return String(opts[camelCase(name)] ?? "");
+    },
+    num(name) {
+      const val = opts[camelCase(name)];
+      return val !== void 0 ? Number(val) : 0;
+    },
+    bool(name) {
+      return Boolean(opts[camelCase(name)]);
+    },
+    json(name) {
+      const val = opts[camelCase(name)];
+      if (val === void 0 || val === null) return void 0;
+      if (typeof val === "object") return val;
+      try {
+        return JSON.parse(String(val));
+      } catch {
+        printError("validation", `Invalid JSON for --${name}: ${val}`);
+        process.exit(1);
+      }
+    },
+    async api(method, path, params, data) {
+      const client = await getClient();
+      if (method.toUpperCase() === "GET") {
+        return client.httpGet(path, params, ctx.host());
+      } else {
+        return client.httpPost(path, params, data, ctx.host());
+      }
+    },
+    async querySql(projectId, sql) {
+      const client = await getClient();
+      return client.querySql(projectId, sql, ctx.host());
+    },
+    async queryReportData(projectId, reportId, qp, eventModel, options) {
+      const client = await getClient();
+      return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
+    },
+    async token() {
+      const { getToken } = await import("./auth-JXELJNDS.js");
+      return getToken(ctx.host());
+    },
+    host() {
+      if (globalOpts.host) return globalOpts.host;
+      return getActiveHost();
+    },
+    mcpUrl() {
+      return globalOpts.mcpUrl;
+    },
+    service() {
+      return cmd.service;
+    },
+    out(data) {
+      printOutput(data, globalOpts.format, globalOpts.jq);
+    }
+  };
+  return ctx;
+}
+function camelCase(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+async function confirm(message) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question(`${message} [y/N] `, (answer) => {
+      rl.close();
+      resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+
+// src/framework/register.ts
+function registerCommands(program2, commands) {
+  const byService = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    const list = byService.get(cmd.service) || [];
+    list.push(cmd);
+    byService.set(cmd.service, list);
+  }
+  for (const [service, cmds] of byService) {
+    let serviceCmd = program2.commands.find((c) => c.name() === service);
+    if (!serviceCmd) {
+      serviceCmd = program2.command(service).description(`${service} domain commands`);
+    }
+    for (const cmd of cmds) {
+      const sub = serviceCmd.command(cmd.command).description(cmd.description);
+      for (const flag of cmd.flags) {
+        const flagStr = buildFlagString(flag);
+        if (flag.type === "boolean") {
+          sub.option(flagStr, flag.desc, (value) => parseBooleanValue(value, flag.name));
+        } else if (flag.default !== void 0) {
+          sub.option(flagStr, flag.desc, String(flag.default));
+        } else {
+          sub.option(flagStr, flag.desc);
+        }
+      }
+      sub.action(async (opts) => {
+        const globalOpts = extractGlobalOptions(program2);
+        await runCommand(cmd, opts, globalOpts);
+      });
+    }
+  }
+}
+function buildFlagString(flag) {
+  const long = `--${flag.name}`;
+  const short = flag.alias ? `-${flag.alias}, ` : "";
+  if (flag.type === "boolean") {
+    return `${short}${long} [value]`;
+  }
+  return `${short}${long} <value>`;
+}
+function parseBooleanValue(value, flagName) {
+  if (value === void 0) {
+    return true;
+  }
+  const normalized = value.toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n" || normalized === "off") {
+    return false;
+  }
+  throw new Error(`Invalid boolean for --${flagName}: ${value}. Use true/false.`);
+}
+function extractGlobalOptions(program2) {
+  const opts = program2.opts();
+  return {
+    host: opts.host,
+    mcpUrl: opts.mcpUrl,
+    format: opts.format || "json",
+    jq: opts.jq,
+    dryRun: opts.dryRun || false,
+    yes: opts.yes || false
+  };
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new CommanderCommand();
+program.name("ae-cli").version(version).description("CLI tool for ThinkingEngine (TE) analytics platform").option("--host <url>", "Override active TE host URL (e.g., https://ta.thinkingdata.cn)").option("--mcp-url <url>", "Override MCP server URL (e.g., http://localhost/mcp/http/example)").option("--format <format>", "Output format: json | table", "json").option("--jq <expr>", "jq filter expression").option("--dry-run", "Show request details without executing", false).option("--yes", "Skip confirmation for write operations", false);
+async function loadCommands() {
+  const commands = [];
+  try {
+    const teAnalysis = await import("./te-analysis-7NN3SY3I.js");
+    commands.push(...teAnalysis.default);
+  } catch {
+  }
+  try {
+    const teAudience = await import("./te-audience-P43BWMHM.js");
+    commands.push(...teAudience.default);
+  } catch {
+  }
+  try {
+    const teMeta = await import("./te-meta-HGYNXVGF.js");
+    commands.push(...teMeta.default);
+  } catch {
+  }
+  try {
+    const teCommon = await import("./te-common-H3IPTI2I.js");
+    commands.push(...teCommon.default);
+  } catch {
+  }
+  try {
+    const engage = await import("./te-engage-UTRVNTGU.js");
+    commands.push(...engage.default);
+  } catch {
+  }
+  try {
+    const community = await import("./community-GMALVSRF.js");
+    commands.push(...community.default);
+  } catch {
+  }
+  try {
+    const dataops = await import("./te-dataops-WCGDBJLF.js");
+    commands.push(...dataops.default);
+  } catch {
+  }
+  return commands;
+}
+async function registerAuthCommands() {
+  try {
+    const { registerAuth } = await import("./auth-L3G3A74I.js");
+    registerAuth(program);
+  } catch {
+  }
+}
+async function registerConfigCommands() {
+  try {
+    const { registerConfig } = await import("./config-Q7J3Z7Z2.js");
+    registerConfig(program);
+  } catch {
+  }
+}
+async function registerApiCommand() {
+  try {
+    const { registerApi } = await import("./raw-ZNVURYMR.js");
+    registerApi(program);
+  } catch {
+  }
+}
+async function main() {
+  const commands = await loadCommands();
+  registerCommands(program, commands);
+  await registerAuthCommands();
+  await registerConfigCommands();
+  await registerApiCommand();
+  program.parse();
+}
+main();

package/dist/raw-ZNVURYMR.js

@@ -0,0 +1,59 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  httpGet,
+  httpPost
+} from "./chunk-3GM5LJZR.js";
+import {
+  resolveHost
+} from "./chunk-RJNLN3KQ.js";
+import "./chunk-OVQOK35G.js";
+
+// src/api/raw.ts
+function registerApi(program) {
+  program.command("api").description("Raw API call: ae-cli api <METHOD> <PATH> [options]").argument("<method>", "HTTP method (GET, POST)").argument("<path>", "API path (e.g., /v1/ta/event/catalog/listEvent)").option("--params <json>", "URL parameters as JSON").option("--data <json>", "Request body as JSON").action(async (method, apiPath, opts) => {
+    const globalOpts = program.opts();
+    const host = resolveHost(globalOpts.host);
+    const format = globalOpts.format || "json";
+    const jq = globalOpts.jq;
+    if (!host) {
+      printError("config", "No TE host configured.", "Run: ae-cli config set-host");
+      process.exit(1);
+    }
+    try {
+      let params = {};
+      let body = void 0;
+      if (opts.params) {
+        try {
+          params = JSON.parse(opts.params);
+        } catch {
+          printError("validation", `Invalid JSON for --params: ${opts.params}`);
+          process.exit(1);
+        }
+      }
+      if (opts.data) {
+        try {
+          body = JSON.parse(opts.data);
+        } catch {
+          printError("validation", `Invalid JSON for --data: ${opts.data}`);
+          process.exit(1);
+        }
+      }
+      let result;
+      if (method.toUpperCase() === "GET") {
+        result = await httpGet(apiPath, params, host);
+      } else {
+        result = await httpPost(apiPath, params, body, host);
+      }
+      printOutput(result, format, jq);
+    } catch (err) {
+      printError("api", err.message);
+      process.exit(1);
+    }
+  });
+}
+export {
+  registerApi
+};