@thinkingai/ae-cli 1.0.1 → 1.0.3

package/dist/config-V7AXKDMB.js

@@ -0,0 +1,242 @@
+import {
+  getAuthStatus,
+  getToken
+} from "./chunk-3CDLNXTD.js";
+import {
+  addHost,
+  listHosts,
+  removeHost,
+  setActiveHost,
+  updateHostLabel
+} from "./chunk-EBFUVWIZ.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

@@ -3,8 +3,9 @@ import {
   printOutput
 } from "./chunk-KM57HI5B.js";
 import {
-  getActiveHost
-} from "./chunk-OVQOK35G.js";
+  getActiveHost,
+  safeJsonParse
+} from "./chunk-EBFUVWIZ.js";
 
 // src/index.ts
 import { Command as CommanderCommand } from "commander";
@@ -61,7 +62,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
   let _clientModule = null;
   async function getClient() {
     if (!_clientModule) {
-      _clientModule = await import("./client-5QSQBBDB.js");
+      _clientModule = await import("./client-T4VODLA6.js");
     }
     return _clientModule;
   }
@@ -81,7 +82,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       if (val === void 0 || val === null) return void 0;
       if (typeof val === "object") return val;
       try {
-        return JSON.parse(String(val));
+        return safeJsonParse(String(val));
       } catch {
         printError("validation", `Invalid JSON for --${name}: ${val}`);
         process.exit(1);
@@ -104,7 +105,7 @@ function createRuntimeContext(cmd, opts, globalOpts) {
       return client.queryReportData(projectId, reportId, qp, eventModel, options, ctx.host());
     },
     async token() {
-      const { getToken } = await import("./auth-JXELJNDS.js");
+      const { getToken } = await import("./auth-BQC5DBE7.js");
       return getToken(ctx.host());
     },
     host() {
@@ -209,37 +210,37 @@ program.name("ae-cli").version(version).description("CLI tool for ThinkingEngine
 async function loadCommands() {
   const commands = [];
   try {
-    const teAnalysis = await import("./te-analysis-7NN3SY3I.js");
+    const teAnalysis = await import("./te-analysis-CHFTDN55.js");
     commands.push(...teAnalysis.default);
   } catch {
   }
   try {
-    const teAudience = await import("./te-audience-P43BWMHM.js");
+    const teAudience = await import("./te-audience-M6LQY6M7.js");
     commands.push(...teAudience.default);
   } catch {
   }
   try {
-    const teMeta = await import("./te-meta-HGYNXVGF.js");
+    const teMeta = await import("./te-meta-FMM7KCVI.js");
     commands.push(...teMeta.default);
   } catch {
   }
   try {
-    const teCommon = await import("./te-common-H3IPTI2I.js");
+    const teCommon = await import("./te-common-BLQ7DVGC.js");
     commands.push(...teCommon.default);
   } catch {
   }
   try {
-    const engage = await import("./te-engage-UTRVNTGU.js");
+    const engage = await import("./te-engage-DXE4R5EW.js");
     commands.push(...engage.default);
   } catch {
   }
   try {
-    const community = await import("./community-GMALVSRF.js");
+    const community = await import("./community-FVDAWGS4.js");
     commands.push(...community.default);
   } catch {
   }
   try {
-    const dataops = await import("./te-dataops-WCGDBJLF.js");
+    const dataops = await import("./te-dataops-V4OTKY35.js");
     commands.push(...dataops.default);
   } catch {
   }
@@ -247,21 +248,21 @@ async function loadCommands() {
 }
 async function registerAuthCommands() {
   try {
-    const { registerAuth } = await import("./auth-L3G3A74I.js");
+    const { registerAuth } = await import("./auth-DXKYLMO7.js");
     registerAuth(program);
   } catch {
   }
 }
 async function registerConfigCommands() {
   try {
-    const { registerConfig } = await import("./config-Q7J3Z7Z2.js");
+    const { registerConfig } = await import("./config-V7AXKDMB.js");
     registerConfig(program);
   } catch {
   }
 }
 async function registerApiCommand() {
   try {
-    const { registerApi } = await import("./raw-ZNVURYMR.js");
+    const { registerApi } = await import("./raw-G3GKHAPZ.js");
     registerApi(program);
   } catch {
   }

package/dist/raw-G3GKHAPZ.js

@@ -0,0 +1,61 @@
+import {
+  printError,
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  httpGet,
+  httpPost
+} from "./chunk-ZYXIGPG7.js";
+import {
+  resolveHost
+} from "./chunk-3CDLNXTD.js";
+import {
+  safeJsonParse
+} from "./chunk-EBFUVWIZ.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 = safeJsonParse(opts.params);
+        } catch {
+          printError("validation", `Invalid JSON for --params: ${opts.params}`);
+          process.exit(1);
+        }
+      }
+      if (opts.data) {
+        try {
+          body = safeJsonParse(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
+};