@zhoujinandrew/te-cli 1.0.0

package/dist/chunk-KAWQCMDL.js

@@ -0,0 +1,44 @@
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".te-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+  } catch {
+  }
+  return { defaultHost: "ta.thinkingdata.cn", hosts: {} };
+}
+function saveConfig(config) {
+  ensureDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getDefaultHost() {
+  return process.env.TE_HOST || loadConfig().defaultHost || "ta.thinkingdata.cn";
+}
+function setConfigValue(key, value) {
+  const config = loadConfig();
+  if (key === "defaultHost") {
+    config.defaultHost = value;
+  } else {
+    config[key] = value;
+  }
+  saveConfig(config);
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+
+export {
+  loadConfig,
+  saveConfig,
+  getDefaultHost,
+  setConfigValue,
+  getConfigDir
+};

package/dist/chunk-KM57HI5B.js

@@ -0,0 +1,107 @@
+// src/framework/output.ts
+import Table from "cli-table3";
+var KNOWN_ARRAY_FIELDS = [
+  "items",
+  "events",
+  "reports",
+  "dashboards",
+  "tags",
+  "clusters",
+  "flows",
+  "tasks",
+  "channels",
+  "nodes",
+  "members",
+  "records",
+  "entities",
+  "metrics",
+  "tables",
+  "columns",
+  "properties"
+];
+function findArrayField(data) {
+  if (Array.isArray(data)) return data;
+  if (typeof data !== "object" || data === null) return null;
+  for (const key of KNOWN_ARRAY_FIELDS) {
+    if (Array.isArray(data[key])) return data[key];
+  }
+  for (const key of Object.keys(data)) {
+    if (Array.isArray(data[key])) return data[key];
+  }
+  return null;
+}
+function formatTable(data) {
+  const rows = findArrayField(data);
+  if (!rows || rows.length === 0) {
+    return JSON.stringify(data, null, 2);
+  }
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (typeof row === "object" && row !== null) {
+      Object.keys(row).forEach((k) => allKeys.add(k));
+    }
+  }
+  const keys = Array.from(allKeys);
+  if (keys.length === 0) return JSON.stringify(rows, null, 2);
+  const table = new Table({ head: keys, wordWrap: true });
+  for (const row of rows) {
+    table.push(keys.map((k) => {
+      const v = row?.[k];
+      if (v === void 0 || v === null) return "";
+      if (typeof v === "object") return JSON.stringify(v);
+      return String(v);
+    }));
+  }
+  return table.toString();
+}
+function applyJq(data, expr) {
+  if (!expr) return data;
+  const parts = expr.replace(/^\.(data\.)?/, "").split(".");
+  let result = data;
+  for (const part of parts) {
+    const arrayMatch = part.match(/^(.+)\[\]$/);
+    if (arrayMatch) {
+      result = result?.[arrayMatch[1]];
+      if (!Array.isArray(result)) return result;
+      continue;
+    }
+    const indexMatch = part.match(/^(.+)\[(\d+)\]$/);
+    if (indexMatch) {
+      result = result?.[indexMatch[1]]?.[parseInt(indexMatch[2])];
+      continue;
+    }
+    if (part) {
+      result = result?.[part];
+    }
+  }
+  return result;
+}
+function formatOutput(data, format, jqExpr) {
+  let processed = data;
+  if (jqExpr) {
+    processed = applyJq(data, jqExpr);
+  }
+  if (format === "table") {
+    return formatTable(processed);
+  }
+  const envelope = { ok: true, data: processed };
+  return JSON.stringify(envelope, null, 2);
+}
+function formatError(type, message, hint, code) {
+  const envelope = {
+    ok: false,
+    error: { type, message, hint, code }
+  };
+  return JSON.stringify(envelope, null, 2);
+}
+function printError(type, message, hint, code) {
+  process.stderr.write(formatError(type, message, hint, code) + "\n");
+}
+function printOutput(data, format, jqExpr) {
+  process.stdout.write(formatOutput(data, format, jqExpr) + "\n");
+}
+
+export {
+  printError,
+  printOutput
+};

package/dist/chunk-KNKRSOCY.js

@@ -0,0 +1,144 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-P7NQZGSZ.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}`;
+}
+function buildUrl(baseUrl, modulePath, params = {}) {
+  const base = baseUrl.replace(/\/$/, "");
+  const p = modulePath.startsWith("/") ? modulePath : `/${modulePath}`;
+  const url = new URL(`${base}${p}`);
+  for (const [k, v] of Object.entries(params)) {
+    if (v !== void 0 && v !== null) url.searchParams.set(k, String(v));
+  }
+  return url.toString();
+}
+function buildWsUrl(baseUrl, token) {
+  const base = baseUrl.replace(/\/$/, "");
+  const wsBase = base.replace(/^https:\/\//, "wss://").replace(/^http:\/\//, "ws://");
+  return `${wsBase}/v1/ta-websocket/query/${token}`;
+}
+async function request(method, modulePath, params = {}, body = null, retry = true, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  const token = await getToken(resolvedHost);
+  const url = buildUrl(resolvedHost, modulePath, params);
+  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, 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 = {}, hostUrl) {
+  return request("GET", modulePath, params, null, true, hostUrl);
+}
+async function httpPost(modulePath, params = {}, body, hostUrl) {
+  return request("POST", modulePath, params, body ?? {}, true, hostUrl);
+}
+async function wsQueryOnce(projectId, requestId, qp, eventModel, options = {}, token, hostUrl, timeoutMs = 3e4) {
+  const wsUrl = buildWsUrl(hostUrl, 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 = {}, hostUrl) {
+  const resolvedHost = resolveHost(hostUrl);
+  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, hostUrl) {
+  const requestId = genRequestId("sqlIde");
+  const qp = {
+    events: { sql },
+    eventView: { sqlViewParams: [] }
+  };
+  return wsQuery(projectId, requestId, qp, 10, {
+    searchSource: "sqlIde",
+    querySource: "sqlIde"
+  }, hostUrl);
+}
+async function queryReportData(projectId, reportId, qp, eventModel, options = {}, hostUrl) {
+  const requestId = genRequestId("reportQuery");
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: "reportQuery",
+    querySource: "single_report",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/chunk-P7NQZGSZ.js

@@ -0,0 +1,217 @@
+import {
+  extractHostname,
+  getActiveHost,
+  getConfigDir
+} from "./chunk-CFCHSAMQ.js";
+
+// src/core/auth.ts
+import fs from "fs";
+import path from "path";
+import { execFileSync } from "child_process";
+var TOKENS_FILE = path.join(getConfigDir(), "tokens.json");
+var LEGACY_DIR = path.join(process.env.HOME || "", ".te-mcp");
+var TOKEN_TTL_MS = 20 * 60 * 60 * 1e3;
+var OSASCRIPT_POLL_INTERVAL_MS = 2e3;
+var OSASCRIPT_POLL_TIMEOUT_MS = 6e4;
+function ensureDir() {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+function resolveHost(hostOverride) {
+  if (hostOverride) return hostOverride;
+  return getActiveHost();
+}
+function loadAllTokens() {
+  try {
+    const legacyTokens = path.join(LEGACY_DIR, "tokens.json");
+    if (fs.existsSync(legacyTokens) && !fs.existsSync(TOKENS_FILE)) {
+      const data = JSON.parse(fs.readFileSync(legacyTokens, "utf-8"));
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        const url = key.startsWith("http") ? key : `https://${key}`;
+        migrated[url] = val;
+      }
+      ensureDir();
+      fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+      return migrated;
+    }
+    if (fs.existsSync(TOKENS_FILE)) {
+      const data = JSON.parse(fs.readFileSync(TOKENS_FILE, "utf-8"));
+      let needsMigration = false;
+      const migrated = {};
+      for (const [key, val] of Object.entries(data)) {
+        if (!key.startsWith("http")) {
+          migrated[`https://${key}`] = val;
+          needsMigration = true;
+        } else {
+          migrated[key] = val;
+        }
+      }
+      if (needsMigration) {
+        fs.writeFileSync(TOKENS_FILE, JSON.stringify(migrated, null, 2));
+        return migrated;
+      }
+      return data;
+    }
+  } catch {
+  }
+  return {};
+}
+function saveAllTokens(tokens) {
+  ensureDir();
+  fs.writeFileSync(TOKENS_FILE, JSON.stringify(tokens, null, 2));
+}
+function loadToken(hostUrl) {
+  const tokens = loadAllTokens();
+  const entry = tokens[hostUrl];
+  if (!entry || !entry.token) return null;
+  if (entry.updatedAt) {
+    const age = Date.now() - new Date(entry.updatedAt).getTime();
+    if (age > TOKEN_TTL_MS) {
+      clearToken(hostUrl);
+      return null;
+    }
+  }
+  return { host: hostUrl, token: entry.token, updatedAt: entry.updatedAt };
+}
+function saveToken(token, hostUrl) {
+  const tokens = loadAllTokens();
+  tokens[hostUrl] = { token, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  saveAllTokens(tokens);
+}
+function clearToken(hostUrl) {
+  const tokens = loadAllTokens();
+  delete tokens[hostUrl];
+  saveAllTokens(tokens);
+}
+function setTokenManual(token, hostUrl) {
+  saveToken(token, hostUrl);
+}
+function getAuthStatus(hostUrl) {
+  if (process.env.TE_TOKEN) {
+    return { authenticated: true, host: hostUrl, source: "env:TE_TOKEN" };
+  }
+  const cached = loadToken(hostUrl);
+  if (cached) {
+    const ageMs = Date.now() - new Date(cached.updatedAt).getTime();
+    const hours = Math.round(ageMs / 36e5);
+    return { authenticated: true, host: hostUrl, tokenAge: `${hours}h ago`, source: "cache" };
+  }
+  return { authenticated: false, host: hostUrl };
+}
+function extractTokenViaOsascript(hostUrl) {
+  if (process.platform !== "darwin") return { token: null, error: "not_mac" };
+  const hostname = extractHostname(hostUrl);
+  const lines = [
+    'tell application "Google Chrome"',
+    "  repeat with w in windows",
+    "    repeat with t in tabs of w",
+    `      if URL of t contains "${hostname}" then`,
+    `        return execute t javascript "localStorage.getItem('ACCESS_TOKEN')"`,
+    "      end if",
+    "    end repeat",
+    "  end repeat",
+    '  return "NO_TAB_FOUND"',
+    "end tell"
+  ];
+  try {
+    const args = lines.flatMap((line) => ["-e", line]);
+    const result = execFileSync("osascript", args, { encoding: "utf8", timeout: 5e3 }).trim();
+    if (result === "NO_TAB_FOUND") return { token: null, error: "no_tab" };
+    if (!result || result === "missing value") return { token: null, error: "no_token" };
+    return { token: result.replace(/^["']|["']$/g, ""), error: null };
+  } catch (e) {
+    const msg = e.message || "";
+    if (msg.includes("not allowed") || msg.includes("assistive access") || msg.includes("(-1743)")) {
+      return { token: null, error: "no_js_permission" };
+    }
+    return { token: null, error: "no_tab" };
+  }
+}
+async function requestTokenViaOsascript(hostUrl) {
+  process.stderr.write(`[te-cli] No TE tab found in Chrome. Opening ${hostUrl} ...
+`);
+  process.stderr.write(`[te-cli] Please login, then your token will be captured automatically.
+`);
+  try {
+    const openScript = [
+      'tell application "Google Chrome"',
+      "  activate",
+      "  if (count of windows) > 0 then",
+      `    make new tab at end of tabs of window 1 with properties {URL:"${hostUrl}"}`,
+      "  else",
+      `    open location "${hostUrl}"`,
+      "  end if",
+      "end tell"
+    ];
+    execFileSync("osascript", openScript.flatMap((line) => ["-e", line]), { timeout: 5e3 });
+  } catch {
+    process.stderr.write(`[te-cli] Could not open browser. Please open ${hostUrl} in Chrome manually.
+`);
+  }
+  const deadline = Date.now() + OSASCRIPT_POLL_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, OSASCRIPT_POLL_INTERVAL_MS));
+    const { token, error } = extractTokenViaOsascript(hostUrl);
+    if (token) {
+      process.stderr.write(`[te-cli] Token captured from Chrome for ${hostUrl}.
+`);
+      return token;
+    }
+    if (error === "no_js_permission") return null;
+  }
+  process.stderr.write(`[te-cli] Polling timed out after ${OSASCRIPT_POLL_TIMEOUT_MS / 1e3}s.
+`);
+  return null;
+}
+async function getToken(hostUrl) {
+  if (!hostUrl) {
+    throw new Error(
+      `No TE host configured.
+Run: te-cli config set-host`
+    );
+  }
+  if (process.env.TE_TOKEN) {
+    return process.env.TE_TOKEN;
+  }
+  const cached = loadToken(hostUrl);
+  if (cached && cached.token) return cached.token;
+  const { token: osascriptToken, error } = extractTokenViaOsascript(hostUrl);
+  if (error === "no_js_permission") {
+    throw new Error(
+      `Chrome JavaScript from Apple Events is not enabled.
+Enable it: Chrome menu \u2192 View \u2192 Developer \u2192 Allow JavaScript from Apple Events`
+    );
+  }
+  if (error === "not_mac") {
+    throw new Error(
+      `Auto token extraction is only available on macOS + Chrome.
+Use: te-cli auth set-token <token>`
+    );
+  }
+  if (osascriptToken) {
+    saveToken(osascriptToken, hostUrl);
+    return osascriptToken;
+  }
+  const polledToken = await requestTokenViaOsascript(hostUrl);
+  if (polledToken) {
+    saveToken(polledToken, hostUrl);
+    return polledToken;
+  }
+  throw new Error(
+    `Cannot obtain token for ${hostUrl}.
+Options:
+  1. te-cli auth login (macOS + Chrome)
+  2. te-cli auth set-token <token>`
+  );
+}
+
+export {
+  resolveHost,
+  loadToken,
+  saveToken,
+  clearToken,
+  setTokenManual,
+  getAuthStatus,
+  getToken
+};

package/dist/chunk-STTYG7WN.js

@@ -0,0 +1,91 @@
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+var CONFIG_DIR = path.join(process.env.HOME || "", ".te-cli");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function ensureDir() {
+  if (!fs.existsSync(CONFIG_DIR)) fs.mkdirSync(CONFIG_DIR, { recursive: true });
+}
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const raw = JSON.parse(fs.readFileSync(CONFIG_FILE, "utf-8"));
+      if (raw.defaultHost && !raw.activeHost) {
+        const migrated = migrateConfig(raw);
+        saveConfig(migrated);
+        return migrated;
+      }
+      return raw;
+    }
+  } catch {
+  }
+  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 = key.startsWith("http") ? key : `https://${key}`;
+      hosts[url] = val;
+    }
+  }
+  const activeHost = oldHost.startsWith("http") ? oldHost : `https://${oldHost}`;
+  if (!hosts[activeHost]) {
+    hosts[activeHost] = { label: "default" };
+  }
+  return { activeHost, hosts };
+}
+function saveConfig(config) {
+  ensureDir();
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getActiveHost() {
+  const config = loadConfig();
+  return config.activeHost;
+}
+function setActiveHost(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) {
+  const config = loadConfig();
+  config.hosts[url] = { label };
+  if (!config.activeHost) {
+    config.activeHost = url;
+  }
+  saveConfig(config);
+}
+function listHosts() {
+  const config = loadConfig();
+  return Object.entries(config.hosts).map(([url, entry]) => ({
+    url,
+    label: entry.label,
+    active: url === config.activeHost
+  }));
+}
+function getConfigDir() {
+  return CONFIG_DIR;
+}
+function extractHostname(fullUrl) {
+  try {
+    const u = new URL(fullUrl);
+    return u.host;
+  } catch {
+    return fullUrl;
+  }
+}
+
+export {
+  loadConfig,
+  getActiveHost,
+  setActiveHost,
+  addHost,
+  listHosts,
+  getConfigDir,
+  extractHostname
+};