@thinkingai/ae-cli 1.0.1 → 1.0.3

package/dist/chunk-ZYXIGPG7.js

@@ -0,0 +1,148 @@
+import {
+  clearToken,
+  getToken,
+  resolveHost
+} from "./chunk-3CDLNXTD.js";
+import {
+  safeJsonParse
+} from "./chunk-EBFUVWIZ.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 = safeJsonParse(await resp.text());
+  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 = safeJsonParse(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 dashboardId = options.dashboardId || 0;
+  const requestId = genRequestId(`${projectId}_${dashboardId}_${reportId}`);
+  return wsQuery(projectId, requestId, qp, eventModel, {
+    searchSource: options.searchSource || "model_search",
+    querySource: options.querySource || "module",
+    ...options
+  }, hostUrl);
+}
+
+export {
+  httpGet,
+  httpPost,
+  wsQuery,
+  querySql,
+  queryReportData
+};

package/dist/client-T4VODLA6.js

@@ -0,0 +1,16 @@
+import {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+} from "./chunk-ZYXIGPG7.js";
+import "./chunk-3CDLNXTD.js";
+import "./chunk-EBFUVWIZ.js";
+export {
+  httpGet,
+  httpPost,
+  queryReportData,
+  querySql,
+  wsQuery
+};