@thinkingai/ae-cli 1.0.22 → 1.0.27

package/dist/chunk-MWWYGZ76.js

@@ -0,0 +1,130 @@
+import {
+  loadMcpTokenStore
+} from "./chunk-2NGWYMLB.js";
+import {
+  forceMigrateFromFallback,
+  safeJsonParse
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
+
+// src/core/mcp-access.ts
+function buildUrl(host, path, params = {}) {
+  const base = host.replace(/\/$/, "");
+  const p = path.startsWith("/") ? path : `/${path}`;
+  const url = new URL(`${base}${p}`);
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0 && value !== null) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  return url.toString();
+}
+function getMcpTokenForHost(host) {
+  const store = loadMcpTokenStore();
+  const normalizedHost = host.replace(/\/+$/, "");
+  if (store[host]) return store[host];
+  if (store[normalizedHost]) return store[normalizedHost];
+  for (const [key, token] of Object.entries(store)) {
+    if (key.replace(/\/+$/, "") === normalizedHost) {
+      return token;
+    }
+  }
+  return void 0;
+}
+function getTokenFromStore(store, host) {
+  const normalizedHost = host.replace(/\/+$/, "");
+  if (store[host]) return store[host];
+  if (store[normalizedHost]) return store[normalizedHost];
+  for (const [key, token] of Object.entries(store)) {
+    if (key.replace(/\/+$/, "") === normalizedHost) {
+      return token;
+    }
+  }
+  return void 0;
+}
+function refreshMcpTokenFromFallback(host) {
+  logger.warn(`KB MCP request failed for ${host}, trying fallback`);
+  const migrated = forceMigrateFromFallback();
+  const token = migrated ? getTokenFromStore(migrated, host) : void 0;
+  if (token) {
+    logger.info(`KB MCP token refreshed from fallback for ${host}`);
+    process.stderr.write(`[ae-cli] MCP token refreshed from fallback for ${host}
+`);
+  }
+  return token;
+}
+function isMcpAuthFailure(resp, data) {
+  return !resp.ok || data.return_code === -1001;
+}
+function parseKbResponse(resp, text) {
+  if (resp.status === 401 || resp.status === 403) {
+    throw new Error(`KB MCP token auth failed: HTTP ${resp.status} ${resp.statusText}`);
+  }
+  const data = safeJsonParse(text);
+  if (data.return_code === -1001) {
+    throw new Error(`KB MCP token auth failed: ${data.return_message || "unauthorized"} (code: ${data.return_code})`);
+  }
+  if (data.return_code !== 0 && data.return_code !== void 0) {
+    throw new Error(`AE API error: ${data.return_message || "unknown"} (code: ${data.return_code})`);
+  }
+  return data.data !== void 0 ? data.data : data;
+}
+async function fetchWithMcpToken(host, input, init, mcpToken) {
+  const headers = new Headers(init.headers);
+  headers.set("mcp-token", mcpToken);
+  const resp = await fetch(input, { ...init, headers });
+  const text = await resp.text();
+  if (!resp.ok) {
+    const refreshedToken = refreshMcpTokenFromFallback(host);
+    if (refreshedToken) {
+      headers.set("mcp-token", refreshedToken);
+      const retryResp = await fetch(input, { ...init, headers });
+      return parseKbResponse(retryResp, await retryResp.text());
+    }
+    return parseKbResponse(resp, text);
+  }
+  const data = safeJsonParse(text);
+  if (isMcpAuthFailure(resp, data)) {
+    const refreshedToken = refreshMcpTokenFromFallback(host);
+    if (refreshedToken) {
+      headers.set("mcp-token", refreshedToken);
+      const retryResp = await fetch(input, { ...init, headers });
+      return parseKbResponse(retryResp, await retryResp.text());
+    }
+  }
+  return parseKbResponse(resp, text);
+}
+async function kbApi(ctx, method, path, params = {}, body) {
+  const host = ctx.host();
+  const mcpToken = getMcpTokenForHost(host);
+  if (!mcpToken) {
+    return ctx.api(method, path, params, body);
+  }
+  const upperMethod = method.toUpperCase();
+  return fetchWithMcpToken(host, buildUrl(host, path, params), {
+    method: upperMethod,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: upperMethod === "GET" ? void 0 : JSON.stringify(body ?? {})
+  }, mcpToken);
+}
+async function kbUpload(ctx, path, form, params = {}) {
+  const host = ctx.host();
+  const mcpToken = getMcpTokenForHost(host);
+  if (!mcpToken) {
+    const { httpUpload } = await import("./client-IU2E5IOL.js");
+    return httpUpload(path, form, params, host);
+  }
+  return fetchWithMcpToken(host, buildUrl(host, path, params), {
+    method: "POST",
+    body: form
+  }, mcpToken);
+}
+
+export {
+  kbApi,
+  kbUpload
+};

package/dist/{chunk-24ZKQWG2.js → chunk-SRRUNQIM.js}

@@ -4,13 +4,17 @@ import {
   getConfigDir,
   safeJsonParse,
   safeReadJsonFile
-} from "./chunk-TMMUBSKW.js";
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.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 MCP_TOKENS_FILE = path.join(getConfigDir(), "mcp-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;
@@ -90,6 +94,7 @@ function saveToken(token, hostUrl) {
   const tokens = loadAllTokens();
   tokens[hostUrl] = { token, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
   saveAllTokens(tokens);
+  logger.info(`Token saved for ${hostUrl}`);
 }
 function clearToken(hostUrl) {
   const tokens = loadAllTokens();
@@ -111,6 +116,23 @@ function getAuthStatus(hostUrl) {
   }
   return { authenticated: false, host: hostUrl };
 }
+function getCachedMcpToken(hostUrl) {
+  try {
+    if (!fs.existsSync(MCP_TOKENS_FILE)) return void 0;
+    const store = safeReadJsonFile(MCP_TOKENS_FILE);
+    const normalizedHost = hostUrl.replace(/\/+$/, "");
+    if (store[hostUrl]) return store[hostUrl];
+    if (store[normalizedHost]) return store[normalizedHost];
+    for (const [key, token] of Object.entries(store)) {
+      if (key.replace(/\/+$/, "") === normalizedHost) {
+        return token;
+      }
+    }
+    return void 0;
+  } catch {
+    return void 0;
+  }
+}
 function extractTokenViaOsascript(hostUrl) {
   if (process.platform !== "darwin") return { token: null, error: "not_mac" };
   const hostname = extractHostname(hostUrl);
@@ -172,6 +194,7 @@ function extractTokenFromAllTabs() {
   }
 }
 async function requestTokenViaOsascript(hostUrl) {
+  logger.info(`Opening Chrome to ${hostUrl} for token extraction`);
   process.stderr.write(`[ae-cli] No AE tab found in Chrome. Opening ${hostUrl} ...
 `);
   process.stderr.write(`[ae-cli] Please login, then your token will be captured automatically.
@@ -189,24 +212,36 @@ async function requestTokenViaOsascript(hostUrl) {
     ];
     execFileSync("osascript", openScript.flatMap((line) => ["-e", line]), { timeout: 5e3 });
   } catch {
+    logger.warn(`Failed to open Chrome, user may need to open ${hostUrl} manually`);
     process.stderr.write(`[ae-cli] Could not open browser. Please open ${hostUrl} in Chrome manually.
 `);
   }
   const deadline = Date.now() + OSASCRIPT_POLL_TIMEOUT_MS;
+  let pollCount = 0;
   while (Date.now() < deadline) {
     await new Promise((r) => setTimeout(r, OSASCRIPT_POLL_INTERVAL_MS));
+    pollCount++;
     let result = extractTokenViaOsascript(hostUrl);
     if (result.error === "no_tab") {
       const fallback = extractTokenFromAllTabs();
-      if (fallback.token) result = fallback;
+      if (fallback.token) {
+        logger.info("Token captured via all-tabs fallback search");
+        result = fallback;
+      }
     }
     if (result.token) {
+      saveToken(result.token, hostUrl);
+      logger.info(`Token captured after ${pollCount} poll(s)`);
       process.stderr.write(`[ae-cli] Token captured from Chrome for ${hostUrl}.
 `);
       return result.token;
     }
-    if (result.error === "no_js_permission") return null;
+    if (result.error === "no_js_permission") {
+      logger.warn("Chrome JS permission denied during polling");
+      return null;
+    }
   }
+  logger.warn(`Token polling timed out after ${OSASCRIPT_POLL_TIMEOUT_MS / 1e3}s (${pollCount} polls)`);
   process.stderr.write(`[ae-cli] Polling timed out after ${OSASCRIPT_POLL_TIMEOUT_MS / 1e3}s.
 `);
   return null;
@@ -219,12 +254,24 @@ Run: ae-cli config set-host`
     );
   }
   if (process.env.TE_TOKEN) {
+    logger.info("Using token from env:TE_TOKEN");
     return process.env.TE_TOKEN;
   }
   const cached = loadToken(hostUrl);
-  if (cached && cached.token) return cached.token;
+  if (cached && cached.token) {
+    logger.info(`Using cached token for ${hostUrl}`);
+    return cached.token;
+  }
+  if (getCachedMcpToken(hostUrl)) {
+    logger.info(`MCP token exists for ${hostUrl}; skipping browser token extraction`);
+    throw new Error(
+      `MCP token already exists for ${hostUrl}; skipped browser login.
+Use an MCP-token aware command, or run: ae-cli auth set-token <token>`
+    );
+  }
   const { token: osascriptToken, error } = extractTokenViaOsascript(hostUrl);
   if (error === "no_js_permission") {
+    logger.warn("Chrome JS Apple Events not enabled");
     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`

package/dist/chunk-TG64AQV4.js

@@ -0,0 +1,262 @@
+// src/core/te-agent-credentials.ts
+import { readFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function getCredentialsPath() {
+  return join(process.env.HOME || homedir(), ".te-agent", "credentials.json");
+}
+function getPersistentEnvPath() {
+  const runtimeRoot = process.env.SANDBOX_RUNTIME_ROOT ?? "/home/ta/te_agent_ta";
+  return join(runtimeRoot, ".env");
+}
+function parseDotEnv(raw) {
+  const result = {};
+  for (const line of raw.split("\n")) {
+    if (/^\s*#/.test(line) || line.trim() === "") continue;
+    const match = /^\s*([^=]+)=(.*)$/.exec(line);
+    if (!match) continue;
+    const key = match[1].trim();
+    let value = match[2].trim();
+    if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.slice(1, -1).replace(/\\"/g, '"');
+    }
+    if (value !== "") result[key] = value;
+  }
+  return result;
+}
+function readPersistentEnv() {
+  const envPath = getPersistentEnvPath();
+  try {
+    const raw = readFileSync(envPath, "utf8");
+    return parseDotEnv(raw);
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    throw new TeAgentCredentialsError(
+      `${envPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
+      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+    );
+  }
+}
+var TeAgentCredentialsError = class extends Error {
+  constructor(message, hint) {
+    super(message);
+    this.hint = hint;
+    this.name = "TeAgentCredentialsError";
+  }
+  hint;
+};
+function readLegacyCredentials() {
+  const credPath = getCredentialsPath();
+  try {
+    const raw = readFileSync(credPath, "utf8");
+    const parsed = JSON.parse(raw);
+    const main = parsed?.mainApp;
+    return main && typeof main === "object" ? main : null;
+  } catch (err) {
+    if (err?.code === "ENOENT") return null;
+    if (err instanceof SyntaxError) {
+      throw new TeAgentCredentialsError(
+        `${credPath} \u89E3\u6790\u5931\u8D25\uFF1A${err.message}`,
+        "\u51ED\u8BC1\u6587\u4EF6\u53EF\u80FD\u5DF2\u635F\u574F\uFF1B\u4E5F\u53EF\u4EE5\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+      );
+    }
+    throw new TeAgentCredentialsError(
+      `${credPath} \u8BFB\u53D6\u5931\u8D25\uFF1A${err?.message ?? err}`,
+      "\u8BF7\u68C0\u67E5\u6587\u4EF6\u6743\u9650\uFF0C\u6216\u901A\u8FC7 TE_CLAUDE_BASE_URL / SANDBOX_ID / SECRET_KEY \u6CE8\u5165\u8FD0\u884C\u65F6\u51ED\u8BC1"
+    );
+  }
+}
+function loadTeAgentCredentials() {
+  const legacy = readLegacyCredentials();
+  const credPath = getCredentialsPath();
+  const envPath = getPersistentEnvPath();
+  const persistent = readPersistentEnv();
+  const url = process.env.TE_CLAUDE_BASE_URL || persistent?.TE_CLAUDE_BASE_URL || legacy?.url;
+  const sandboxId = process.env.SANDBOX_ID || persistent?.SANDBOX_ID || legacy?.sandboxId;
+  const sandboxSecretKey = process.env.SECRET_KEY || process.env.SANDBOX_SECRET_KEY || persistent?.SECRET_KEY || persistent?.SANDBOX_SECRET_KEY || legacy?.sandboxSecretKey || legacy?.secretKey;
+  if (typeof url !== "string" || !url) {
+    throw new TeAgentCredentialsError(
+      "TE_CLAUDE_BASE_URL \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  if (typeof sandboxId !== "string" || !sandboxId) {
+    throw new TeAgentCredentialsError(
+      "SANDBOX_ID \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  if (typeof sandboxSecretKey !== "string" || !sandboxSecretKey) {
+    throw new TeAgentCredentialsError(
+      "SECRET_KEY \u7F3A\u5931",
+      `\u8BF7\u5728 te-agent \u6C99\u7BB1\u5185\u6267\u884C\uFF0C\u6216\u914D\u7F6E ${envPath} / ${credPath}`
+    );
+  }
+  return { mainApp: { url, sandboxId, sandboxSecretKey } };
+}
+function getClaudeConfigDir() {
+  const fromEnv = process.env.CLAUDE_CONFIG_DIR;
+  if (typeof fromEnv === "string" && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return join(homedir(), ".claude");
+}
+
+// src/core/te-agent-client.ts
+var TeAgentApiError = class extends Error {
+  constructor(message, status, code, body) {
+    super(message);
+    this.status = status;
+    this.code = code;
+    this.body = body;
+    this.name = "TeAgentApiError";
+  }
+  status;
+  code;
+  body;
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var UPLOAD_TIMEOUT_MS = 12e4;
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...init, signal: controller.signal });
+  } catch (err) {
+    if (err?.name === "AbortError") {
+      throw new TeAgentApiError(`\u8BF7\u6C42\u8D85\u65F6\uFF08${timeoutMs}ms\uFF09\uFF1A${url}`, 0, "TIMEOUT");
+    }
+    throw new TeAgentApiError(`\u7F51\u7EDC\u8BF7\u6C42\u5931\u8D25\uFF1A${err?.message ?? err}`, 0, "NETWORK_ERROR");
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function signRequest(method, path, rawBody) {
+  const cred = loadTeAgentCredentials();
+  const { url: baseUrl, sandboxId, sandboxSecretKey } = cred.mainApp;
+  const headers = {
+    "X-Sandbox-Id": sandboxId,
+    "X-Sandbox-Secret-Key": sandboxSecretKey
+  };
+  if (method === "POST" || method === "PATCH") {
+    headers["Content-Type"] = "application/json";
+  }
+  return {
+    url: `${baseUrl.replace(/\/$/, "")}${path}`,
+    headers,
+    rawBody
+  };
+}
+async function parseResponse(response, defaultErrorPrefix) {
+  const text = await response.text();
+  let parsed = void 0;
+  if (text) {
+    try {
+      parsed = JSON.parse(text);
+    } catch {
+      parsed = text;
+    }
+  }
+  if (!response.ok) {
+    const message = typeof parsed === "object" && parsed && typeof parsed.error === "string" ? parsed.error : `${defaultErrorPrefix} ${response.status}`;
+    const code = typeof parsed === "object" && parsed && typeof parsed.code === "string" ? parsed.code : void 0;
+    throw new TeAgentApiError(message, response.status, code, parsed);
+  }
+  return parsed;
+}
+async function postToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = signRequest("POST", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "POST",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function getFromMainApp(path) {
+  const signed = signRequest("GET", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "GET",
+    headers: signed.headers
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function getSandboxModels(currentModelId) {
+  const qs = currentModelId ? `?current=${encodeURIComponent(currentModelId)}` : "";
+  const data = await getFromMainApp(`/api/sandbox/models${qs}`);
+  return Array.isArray(data?.models) ? data.models : [];
+}
+async function postSandboxModelSelection(args) {
+  return postToMainApp("/api/sandbox/models/select", args);
+}
+async function getSandboxSyncPullCandidates(args) {
+  const qs = new URLSearchParams({
+    workspacePath: args.workspacePath,
+    kind: args.kind
+  });
+  return getFromMainApp(
+    `/api/sandbox/sync/pull/candidates?${qs.toString()}`
+  );
+}
+async function postSandboxSyncPull(args) {
+  return postToMainApp("/api/sandbox/sync/pull", {
+    workspacePath: args.workspacePath,
+    kind: args.kind,
+    skills: args.skills,
+    mcp: args.mcp,
+    mode: "merge",
+    ifUnmodifiedSince: args.ifUnmodifiedSince
+  });
+}
+async function deleteFromMainApp(path) {
+  const signed = signRequest("DELETE", path, "");
+  const response = await fetchWithTimeout(signed.url, {
+    method: "DELETE",
+    headers: signed.headers
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function patchToMainApp(path, body) {
+  const rawBody = JSON.stringify(body);
+  const signed = signRequest("PATCH", path, rawBody);
+  const response = await fetchWithTimeout(signed.url, {
+    method: "PATCH",
+    headers: signed.headers,
+    body: signed.rawBody
+  });
+  return parseResponse(response, "\u4E3B\u5E94\u7528\u8FD4\u56DE");
+}
+async function uploadToMainApp(path, formData) {
+  const cred = loadTeAgentCredentials();
+  const baseUrl = cred.mainApp.url.replace(/\/$/, "");
+  const url = `${baseUrl}${path}`;
+  const response = await fetchWithTimeout(
+    url,
+    {
+      method: "POST",
+      headers: {
+        "X-Sandbox-Id": cred.mainApp.sandboxId,
+        "X-Sandbox-Secret-Key": cred.mainApp.sandboxSecretKey
+      },
+      body: formData
+    },
+    UPLOAD_TIMEOUT_MS
+  );
+  return parseResponse(response, "\u4E0A\u4F20\u5931\u8D25");
+}
+
+export {
+  TeAgentCredentialsError,
+  getClaudeConfigDir,
+  TeAgentApiError,
+  postToMainApp,
+  getFromMainApp,
+  getSandboxModels,
+  postSandboxModelSelection,
+  getSandboxSyncPullCandidates,
+  postSandboxSyncPull,
+  deleteFromMainApp,
+  patchToMainApp,
+  uploadToMainApp
+};

package/dist/{chunk-NBFTPIAH.js → chunk-VT6VC4PA.js}

@@ -2,10 +2,13 @@ import {
   clearToken,
   getToken,
   resolveHost
-} from "./chunk-24ZKQWG2.js";
+} from "./chunk-SRRUNQIM.js";
 import {
   safeJsonParse
-} from "./chunk-TMMUBSKW.js";
+} from "./chunk-BI5ZVD6T.js";
+import {
+  logger
+} from "./chunk-MNHE6SSI.js";
 
 // src/core/client.ts
 import WebSocket from "ws";
@@ -39,11 +42,13 @@ async function request(method, modulePath, params = {}, body = null, retry = tru
   const options = { method, headers };
   if (body && method !== "GET") options.body = JSON.stringify(body);
   const resp = await fetch(url, options);
+  const text = await resp.text();
+  const data = safeJsonParse(text);
+  logger.api(method, url, resp.status, body, data);
   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);
@@ -59,6 +64,9 @@ async function httpGet(modulePath, params = {}, hostUrl) {
 async function httpPost(modulePath, params = {}, body, hostUrl) {
   return request("POST", modulePath, params, body ?? {}, true, hostUrl);
 }
+async function httpRequest(method, modulePath, params = {}, body, hostUrl) {
+  return request(method.toUpperCase(), modulePath, params, body ?? {}, true, hostUrl);
+}
 async function httpDelete(modulePath, params = {}, body, hostUrl) {
   return request("DELETE", modulePath, params, body ?? null, true, hostUrl);
 }
@@ -70,11 +78,13 @@ async function uploadRequest(modulePath, form, params = {}, retry = true, hostUr
     "Authorization": `bearer ${token}`
   };
   const resp = await fetch(url, { method: "POST", headers, body: form });
+  const text = await resp.text();
+  const data = safeJsonParse(text);
+  logger.api("POST", url, resp.status, { upload: true }, data);
   if ((resp.status === 401 || resp.status === 403) && retry) {
     clearToken(resolvedHost);
     return uploadRequest(modulePath, form, params, false, resolvedHost);
   }
-  const data = safeJsonParse(await resp.text());
   if (data.return_code === -1001 && retry) {
     clearToken(resolvedHost);
     return uploadRequest(modulePath, form, params, false, resolvedHost);
@@ -170,6 +180,7 @@ async function queryReportData(projectId, reportId, qp, eventModel, options = {}
 export {
   httpGet,
   httpPost,
+  httpRequest,
   httpDelete,
   httpUpload,
   wsQuery,

package/dist/{client-7S23DVHH.js → client-IU2E5IOL.js}

@@ -2,17 +2,20 @@ import {
   httpDelete,
   httpGet,
   httpPost,
+  httpRequest,
   httpUpload,
   queryReportData,
   querySql,
   wsQuery
-} from "./chunk-NBFTPIAH.js";
-import "./chunk-24ZKQWG2.js";
-import "./chunk-TMMUBSKW.js";
+} from "./chunk-VT6VC4PA.js";
+import "./chunk-SRRUNQIM.js";
+import "./chunk-BI5ZVD6T.js";
+import "./chunk-MNHE6SSI.js";
 export {
   httpDelete,
   httpGet,
   httpPost,
+  httpRequest,
   httpUpload,
   queryReportData,
   querySql,

package/dist/{config-RVUESJRF.js → config-WH3R3IRY.js}

@@ -4,14 +4,15 @@ import {
   getToken,
   loadToken,
   validateToken
-} from "./chunk-24ZKQWG2.js";
+} from "./chunk-SRRUNQIM.js";
 import {
   addHost,
   listHosts,
   removeHost,
   setActiveHost,
   updateHostLabel
-} from "./chunk-TMMUBSKW.js";
+} from "./chunk-BI5ZVD6T.js";
+import "./chunk-MNHE6SSI.js";
 
 // src/commands/config.ts
 import * as readline from "readline";