@zhoujinandrew/te-cli 1.0.0

package/dist/chunk-V3D6XL5Z.js

@@ -0,0 +1,134 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-C3VJLU5Y.js";
+
+// src/core/client.ts
+import WebSocket from "ws";
+import { randomBytes } from "crypto";
+function genRequestId(prefix) {
+  const rand = randomBytes(4).toString("base64url").slice(0, 8);
+  return `${prefix}@@${rand}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, host) {
+  const resolvedHost = resolveHost(host);
+  const token = await getToken(resolvedHost);
+  const url = new URL(`https://${resolvedHost}${modulePath}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  const headers = {
+    "Authorization": `bearer ${token}`,
+    "Content-Type": "application/json"
+  };
+  const options = { method, headers };
+  if (body && method !== "GET") options.body = JSON.stringify(body);
+  const resp = await fetch(url.toString(), options);
+  if ((resp.status === 401 || resp.status === 403) && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  const data = await resp.json();
+  if (data.return_code === -1001 && retry) {
+    clearToken(resolvedHost);
+    return request(method, modulePath, params, body, false, resolvedHost);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`TE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function httpGet(modulePath, params = {}, host) {
+  return request("GET", modulePath, params, null, true, host);
+}
+async function httpPost(modulePath, params = {}, body, host) {
+  return request("POST", modulePath, params, body ?? {}, true, host);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, host, timeoutMs = 3e4) {
+  const resolvedHost = resolveHost(host);
+  const wsUrl = `wss://${resolvedHost}/v1/ta-websocket/query/${token}`;
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(wsUrl);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`WebSocket query timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    ws.on("open", () => {
+      const payload = {
+        requestId,
+        projectId,
+        eventModel,
+        qp: typeof qp === "string" ? qp : JSON.stringify(qp),
+        searchSource: options.searchSource || "reportQuery",
+        querySource: options.querySource || "single_report",
+        contentTranslate: options.contentTranslate !== false,
+        ...options.extra || {}
+      };
+      ws.send(JSON.stringify(["data", payload, { channel: "ta" }]));
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (Array.isArray(msg) && msg.length >= 2) {
+          const data = msg[1];
+          if (data.requestId === requestId && data.progress === 100) {
+            clearTimeout(timer);
+            ws.close();
+            resolve(data);
+          }
+        }
+      } catch {
+      }
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+    ws.on("close", () => {
+      clearTimeout(timer);
+    });
+  });
+}
+async function wsQuery(projectId, requestId, qp, eventModel, options = {}, host) {
+  const resolvedHost = resolveHost(host);
+  const token = await getToken(resolvedHost);
+  try {
+    return await wsQueryOnce(projectId, requestId, qp, eventModel, options, token, resolvedHost);
+  } catch (err) {
+    const msg = err.message || "";
+    if (msg.includes("401") || msg.includes("403") || msg.includes("auth")) {
+      clearToken(resolvedHost);
+      const newToken = await getToken(resolvedHost);
+      return wsQueryOnce(projectId, requestId, qp, eventModel, options, newToken, resolvedHost);
+    }
+    throw err;
+  }
+}
+async function querySql(projectId, sql, host) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, host);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, host) {
+  const requestId = genRequestId("reportQuery");
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: "reportQuery",
+    querySource: "single_report",
+    ...options
+  }, host);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/client-CSJ3XBC4.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-V3D6XL5Z.js";
+import "./chunk-C3VJLU5Y.js";
+import "./chunk-KAWQCMDL.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};

package/dist/client-EZSKQFIH.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-KNKRSOCY.js";
+import "./chunk-P7NQZGSZ.js";
+import "./chunk-CFCHSAMQ.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};

package/dist/client-OT7PTMI2.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-KA66K7EL.js";
+import "./chunk-4YPCK7T5.js";
+import "./chunk-STTYG7WN.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};

package/dist/config-53KUB7OG.js

@@ -0,0 +1,146 @@
+import {
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  addHost,
+  getConfigDir,
+  listHosts,
+  loadConfig,
+  setActiveHost
+} from "./chunk-STTYG7WN.js";
+
+// src/commands/config.ts
+import * as readline from "readline";
+function registerConfig(program) {
+  const config = program.command("config").description("Configuration management");
+  config.command("init").description("Initialize te-cli configuration with a TE host").action(async () => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    const ask = (q, def) => new Promise((resolve) => rl.question(`${q} [${def}]: `, (a) => resolve(a || def)));
+    const url = await ask("TE host URL", "https://ta.thinkingdata.cn");
+    const label = await ask("Label for this host", "default");
+    rl.close();
+    const normalized = normalizeUrl(url);
+    addHost(normalized, label);
+    setActiveHost(normalized);
+    process.stderr.write(`[te-cli] Config saved. Active host: ${normalized}
+`);
+    printOutput(loadConfig(), program.opts().format || "json");
+  });
+  config.command("show").description("Show current configuration").action(() => {
+    const cfg = loadConfig();
+    const hosts = listHosts();
+    printOutput({ configDir: getConfigDir(), activeHost: cfg.activeHost, hosts }, program.opts().format || "json");
+  });
+  config.command("add-host").description("Add a new TE host").argument("<url>", "Full URL (e.g., https://ta.thinkingdata.cn:8080)").option("--label <label>", "Label for this host", "default").action((url, opts) => {
+    const normalized = normalizeUrl(url);
+    addHost(normalized, opts.label);
+    process.stderr.write(`[te-cli] Host added: ${normalized} (${opts.label})
+`);
+    printOutput({ added: normalized, label: opts.label }, program.opts().format || "json");
+  });
+  config.command("set-host").description("Switch active TE host (interactive selector)").action(async () => {
+    const hosts = listHosts();
+    if (hosts.length === 0) {
+      process.stderr.write("[te-cli] No hosts configured. Run: te-cli config add-host <url>\n");
+      process.exit(1);
+    }
+    const options = [
+      ...hosts.map((h) => ({
+        label: `${h.active ? "\u25CF " : "  "}${h.url} (${h.label})`,
+        value: h.url,
+        isNew: false
+      })),
+      { label: "  + Add new host...", value: "__new__", isNew: true }
+    ];
+    const activeIdx = hosts.findIndex((h) => h.active);
+    const selected = await interactiveSelect(options.map((o) => o.label), activeIdx >= 0 ? activeIdx : 0);
+    if (selected === -1) {
+      process.stderr.write("Cancelled.\n");
+      return;
+    }
+    const chosen = options[selected];
+    if (chosen.isNew) {
+      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: ");
+      const label = await ask("Label: ");
+      rl.close();
+      if (!url) {
+        process.stderr.write("Cancelled.\n");
+        return;
+      }
+      const normalized = normalizeUrl(url);
+      addHost(normalized, label || "default");
+      setActiveHost(normalized);
+      process.stderr.write(`[te-cli] Added and switched to: ${normalized}
+`);
+    } else {
+      setActiveHost(chosen.value);
+      process.stderr.write(`[te-cli] Switched to: ${chosen.value}
+`);
+    }
+    printOutput(loadConfig(), program.opts().format || "json");
+  });
+}
+function normalizeUrl(url) {
+  if (!url.startsWith("http://") && !url.startsWith("https://")) {
+    url = `https://${url}`;
+  }
+  return url.replace(/\/$/, "");
+}
+function interactiveSelect(items, initialIndex) {
+  return new Promise((resolve) => {
+    let cursor = initialIndex;
+    const stdin = process.stdin;
+    const stderr = process.stderr;
+    stderr.write("\x1B[?25l");
+    function render() {
+      if (renderCount > 0) {
+        stderr.write(`\x1B[${items.length}A`);
+      }
+      for (let i = 0; i < items.length; i++) {
+        const prefix = i === cursor ? "\x1B[36m\u276F\x1B[0m" : " ";
+        const text = i === cursor ? `\x1B[1m${items[i]}\x1B[0m` : items[i];
+        stderr.write(`${prefix} ${text}\x1B[K
+`);
+      }
+      renderCount++;
+    }
+    let renderCount = 0;
+    stderr.write("Use \u2191\u2193 arrows to select, Enter to confirm, Esc to cancel:\n");
+    render();
+    if (!stdin.isTTY) {
+      stderr.write("\x1B[?25h");
+      resolve(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(cursor);
+      } else if (key === "\x1B" || key === "") {
+        cleanup();
+        resolve(-1);
+      }
+    }
+    stdin.on("data", onData);
+  });
+}
+export {
+  registerConfig
+};

package/dist/config-QQE7LMPZ.js

@@ -0,0 +1,40 @@
+import {
+  printOutput
+} from "./chunk-KM57HI5B.js";
+import {
+  getConfigDir,
+  loadConfig,
+  saveConfig,
+  setConfigValue
+} from "./chunk-KAWQCMDL.js";
+
+// src/commands/config.ts
+import * as readline from "readline";
+function registerConfig(program) {
+  const config = program.command("config").description("Configuration management");
+  config.command("init").description("Initialize te-cli configuration").action(async () => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+    const ask = (q, def) => new Promise((resolve) => rl.question(`${q} [${def}]: `, (a) => resolve(a || def)));
+    const host = await ask("Default TE host", "ta.thinkingdata.cn");
+    const label = await ask("Label for this host", "default");
+    rl.close();
+    const cfg = { defaultHost: host, hosts: { [host]: { label } } };
+    saveConfig(cfg);
+    process.stderr.write(`[te-cli] Config saved to ${getConfigDir()}/config.json
+`);
+    printOutput(cfg, program.opts().format || "json");
+  });
+  config.command("show").description("Show current configuration").action(() => {
+    const cfg = loadConfig();
+    printOutput({ configDir: getConfigDir(), ...cfg }, program.opts().format || "json");
+  });
+  config.command("set <key> <value>").description("Set a configuration value (e.g., defaultHost)").action((key, value) => {
+    setConfigValue(key, value);
+    process.stderr.write(`[te-cli] Set ${key} = ${value}
+`);
+    printOutput({ [key]: value }, program.opts().format || "json");
+  });
+}
+export {
+  registerConfig
+};

package/dist/config-S53L4MQK.js

@@ -0,0 +1,242 @@
+import {
+  getAuthStatus,
+  getToken
+} from "./chunk-P7NQZGSZ.js";
+import {
+  addHost,
+  listHosts,
+  removeHost,
+  setActiveHost,
+  updateHostLabel
+} from "./chunk-CFCHSAMQ.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[te-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 te-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: te-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
+};