@thinkingai/ae-cli 6.0.40 → 6.0.41

package/dist/chunk-WANVG6SY.js

@@ -0,0 +1,556 @@
+import {
+  CapabilityGatewayError,
+  fetchCapabilityGateway,
+  requestCapabilityGateway
+} from "./chunk-JUW4AJXN.js";
+import {
+  readOutputMetadata,
+  unwrapOutputData,
+  withOutputMetadata
+} from "./chunk-WZRX4KOH.js";
+import {
+  resolveGatewayDomain
+} from "./chunk-PTE56QPL.js";
+import {
+  PermissionError
+} from "./chunk-AXDXJTPC.js";
+
+// src/core/analysis-async-artifact.ts
+import { randomBytes } from "crypto";
+import { createWriteStream } from "fs";
+import { access, link, mkdir, rename, stat, unlink } from "fs/promises";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+import { basename, dirname, join, resolve } from "path";
+var MATERIALIZATION_GRACE_MS = 6e4;
+var DEFAULT_EFFECTIVE_TIMEOUT_MS = 216e5;
+var DEFAULT_WAIT_TIMEOUT_SECONDS = 600;
+var MAX_WAIT_TIMEOUT_SECONDS = 21600;
+var MAX_TRANSIENT_FAILURES = 3;
+var asyncArtifactLifecycleFlags = [
+  {
+    name: "wait",
+    type: "boolean",
+    required: false,
+    desc: "Wait for the remote run and artifact to reach a terminal state. Polling uses short inspect requests; interrupting does not cancel the remote run."
+  },
+  {
+    name: "wait-timeout-seconds",
+    type: "number",
+    required: false,
+    min: 1,
+    max: MAX_WAIT_TIMEOUT_SECONDS,
+    desc: "Maximum time this CLI process waits. Default: 600 seconds; expiry never cancels the remote run."
+  },
+  {
+    name: "output",
+    type: "string",
+    required: false,
+    desc: "Wait, then stream the completed artifact to this local file. Implies --wait."
+  },
+  {
+    name: "force",
+    type: "boolean",
+    required: false,
+    desc: "Allow --output to atomically replace an existing file. Without this flag, existing paths are refused."
+  }
+];
+function withAsyncArtifactLifecycle(command, options = {}) {
+  const originalValidate = command.validate;
+  const originalPreflight = command.preflight;
+  return {
+    ...command,
+    flags: [...command.flags, ...asyncArtifactLifecycleFlags],
+    validate: (ctx) => {
+      originalValidate?.(ctx);
+      validateLifecycleFlags(ctx);
+    },
+    preflight: (ctx) => {
+      originalPreflight?.(ctx);
+      validateLifecycleFlags(ctx);
+    },
+    execute: async (ctx) => {
+      validateLifecycleFlags(ctx);
+      const output = optionalString(ctx, "output");
+      if (output) {
+        if (options.preflightOutput) {
+          await options.preflightOutput({
+            ctx,
+            output,
+            force: ctx.bool("force")
+          });
+        } else {
+          await assertOutputPathAvailable(output, ctx.bool("force"));
+        }
+      }
+      const submission = await command.execute(ctx);
+      const descriptor = asDescriptor(unwrapOutputData(submission));
+      const runId = nonEmptyString(descriptor.run_id);
+      const artifactId = descriptorArtifactId(descriptor);
+      if (!runId || !artifactId) {
+        throw protocolError(
+          "Async artifact submission did not return both run_id and artifact_id.",
+          runId
+        );
+      }
+      announceSubmitted(runId, artifactId);
+      if (!ctx.bool("wait") && output === void 0) {
+        return submission;
+      }
+      const finalResult = await withInterruptSignal(async (signal) => {
+        const finalDescriptor = await waitForAnalysisRun(ctx.host(), runId, {
+          expectedArtifactId: artifactId,
+          initialDescriptor: descriptor,
+          signal,
+          waitTimeoutSeconds: clientWaitTimeoutSeconds(ctx)
+        });
+        if (!output) return finalDescriptor;
+        const download = options.materialize ? await options.materialize({
+          ctx,
+          runId,
+          artifactId,
+          output,
+          force: ctx.bool("force"),
+          signal,
+          finalDescriptor
+        }) : await downloadAnalysisArtifact(
+          ctx.host(),
+          runId,
+          artifactId,
+          output,
+          { force: ctx.bool("force"), signal, ensureReady: false }
+        );
+        return { ...finalDescriptor, ...download };
+      }, runId);
+      return withOutputMetadata(finalResult, readOutputMetadata(submission));
+    }
+  };
+}
+async function waitForAnalysisRun(host, runId, options = {}) {
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? abortableSleep;
+  const inspect = options.inspect ?? inspectAnalysisRun;
+  const startedAt = now();
+  const waitTimeoutSeconds = options.waitTimeoutSeconds ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
+  const clientDeadline = startedAt + waitTimeoutSeconds * 1e3;
+  let deadline = deriveDeadline(options.initialDescriptor, startedAt);
+  let delayMs = 1e3;
+  let transientFailures = 0;
+  let lastState = "";
+  let materializationStartedAt;
+  let descriptor = options.initialDescriptor;
+  while (true) {
+    throwIfAborted(options.signal, runId);
+    if (descriptor !== void 0 && descriptorRunStatus(descriptor) === void 0) {
+      descriptor = void 0;
+    }
+    if (descriptor === void 0) {
+      try {
+        descriptor = asDescriptor(await inspect(host, runId));
+        transientFailures = 0;
+      } catch (error) {
+        if (error instanceof PermissionError) throw error;
+        if (error instanceof CapabilityGatewayError && error.httpStatus === 404) {
+          throw new CapabilityGatewayError(
+            `Async run ${runId} was not found on the current host.`,
+            "ASYNC_RUN_NOT_FOUND",
+            404,
+            "Do not keep polling. Verify that the run ID belongs to this host and that the run lifecycle route is deployed.",
+            { run_id: runId }
+          );
+        }
+        if (!isTransientPollError(error) || ++transientFailures >= MAX_TRANSIENT_FAILURES) {
+          throw waitError(
+            `Could not inspect async run ${runId}${transientFailures > 0 ? ` after ${transientFailures} transient failures` : ""}.`,
+            "ASYNC_RUN_INSPECT_FAILED",
+            runId,
+            error
+          );
+        }
+        await sleep(delayMs, options.signal);
+        delayMs = nextDelay(delayMs);
+        continue;
+      }
+    }
+    deadline = Math.min(deadline, deriveDeadline(descriptor, startedAt));
+    const runStatus = descriptorRunStatus(descriptor);
+    const artifactStatus = normalizedStatus(descriptor.artifact_status ?? descriptor.artifact?.status);
+    const artifactId = descriptorArtifactId(descriptor);
+    if (options.expectedArtifactId && artifactId && artifactId !== options.expectedArtifactId) {
+      throw new CapabilityGatewayError(
+        `artifact_id ${artifactId} does not match the submitted artifact ${options.expectedArtifactId}.`,
+        "ARTIFACT_RUN_MISMATCH",
+        400,
+        resumeHint(runId),
+        { run_id: runId, artifact_id: artifactId, expected_artifact_id: options.expectedArtifactId }
+      );
+    }
+    const state = `${runStatus || "UNKNOWN"}/${artifactStatus || "UNKNOWN"}`;
+    if (state !== lastState) {
+      process.stderr.write(`[ae-cli] run_id=${runId} state=${state}
+`);
+      lastState = state;
+    }
+    if (runStatus === "FAILED" || runStatus === "CANCELED") {
+      throw terminalError(descriptor, runId, `Run ended with status ${runStatus}.`);
+    }
+    if (artifactStatus === "FAILED" || artifactStatus === "CANCELED") {
+      throw terminalError(descriptor, runId, `Artifact ended with status ${artifactStatus}.`);
+    }
+    if (runStatus === "SUCCEEDED" && artifactStatus === "COMPLETED") {
+      if (!artifactId) {
+        throw protocolError("Completed async run has no artifact_id.", runId);
+      }
+      return descriptor;
+    }
+    if (runStatus !== "RUNNING" && runStatus !== "SUCCEEDED") {
+      throw protocolError(`Unknown async run status: ${runStatus || "missing"}.`, runId);
+    }
+    if (artifactStatus && artifactStatus !== "RUNNING" && artifactStatus !== "COMPLETED") {
+      throw protocolError(`Unknown async artifact status: ${artifactStatus}.`, runId);
+    }
+    if (runStatus === "RUNNING" && artifactStatus === "COMPLETED") {
+      throw protocolError("Artifact is COMPLETED while its run is still RUNNING.", runId);
+    }
+    if (runStatus === "SUCCEEDED" && materializationStartedAt === void 0) {
+      materializationStartedAt = now();
+    }
+    const lifecycleDeadline = materializationStartedAt === void 0 ? deadline : Math.min(deadline, materializationStartedAt + MATERIALIZATION_GRACE_MS);
+    const effectiveDeadline = Math.min(clientDeadline, lifecycleDeadline);
+    if (now() >= effectiveDeadline) {
+      if (clientDeadline <= lifecycleDeadline) {
+        throw waitError(
+          `Stopped waiting after ${waitTimeoutSeconds} seconds for run ${runId}. The remote run was not canceled.`,
+          "ASYNC_WAIT_TIMEOUT",
+          runId,
+          void 0,
+          descriptor,
+          { wait_timeout_seconds: waitTimeoutSeconds }
+        );
+      }
+      throw waitError(
+        `Stopped waiting because the server-declared deadline for run ${runId} was reached. The remote run was not canceled.`,
+        "ASYNC_WAIT_DEADLINE_REACHED",
+        runId,
+        void 0,
+        descriptor
+      );
+    }
+    await sleep(Math.min(delayMs, Math.max(0, effectiveDeadline - now())), options.signal);
+    delayMs = nextDelay(delayMs);
+    descriptor = void 0;
+  }
+}
+async function downloadAnalysisArtifact(host, runId, artifactId, output, options = {}) {
+  const outputPath = resolve(output);
+  await assertOutputPathAvailable(outputPath, options.force, { run_id: runId, artifact_id: artifactId });
+  if (options.ensureReady !== false) {
+    const descriptor = await inspectAnalysisRun(host, runId);
+    ensureCompletedDescriptor(descriptor, runId, artifactId);
+  }
+  await mkdir(dirname(outputPath), { recursive: true });
+  const tempPath = join(
+    dirname(outputPath),
+    `.${basename(outputPath)}.part-${process.pid}-${randomBytes(6).toString("hex")}`
+  );
+  let tempPresent = false;
+  try {
+    throwIfAborted(options.signal, runId);
+    const response = await fetchArtifact(host, runId, artifactId);
+    if (!response.body) {
+      throw protocolError("Artifact download response has no body.", runId);
+    }
+    tempPresent = true;
+    const source = Readable.fromWeb(response.body);
+    await pipeline(source, createWriteStream(tempPath, { flags: "wx" }), {
+      signal: options.signal
+    });
+    const file = await stat(tempPath);
+    if (options.force) {
+      await rename(tempPath, outputPath);
+    } else {
+      try {
+        await link(tempPath, outputPath);
+      } catch (error) {
+        if (error?.code === "EEXIST") {
+          throw new CapabilityGatewayError(
+            `Output path already exists: ${outputPath}`,
+            "OUTPUT_ALREADY_EXISTS",
+            409,
+            "Choose another --output path or pass --force to replace the existing file.",
+            { run_id: runId, artifact_id: artifactId, output_path: outputPath }
+          );
+        }
+        throw error;
+      }
+      await unlink(tempPath);
+    }
+    tempPresent = false;
+    return {
+      run_id: runId,
+      artifact_id: artifactId,
+      output_path: outputPath,
+      bytes: file.size,
+      content_type: response.headers.get("content-type") ?? void 0,
+      content_encoding: response.headers.get("content-encoding") ?? void 0,
+      content_disposition: response.headers.get("content-disposition") ?? void 0
+    };
+  } catch (error) {
+    if (options.signal?.aborted) {
+      throw interruptedError(runId);
+    }
+    throw error;
+  } finally {
+    if (tempPresent) await unlink(tempPath).catch(() => void 0);
+  }
+}
+function validateLifecycleFlags(ctx, waitImplied = false) {
+  const output = optionalString(ctx, "output");
+  if (ctx.bool("force") && output === void 0) {
+    const error = new Error("--force requires --output.");
+    error.type = "validation";
+    throw error;
+  }
+  const waitTimeout = optionalContextNumber(ctx, "wait-timeout-seconds");
+  if (waitTimeout !== void 0) {
+    if (!Number.isInteger(waitTimeout) || waitTimeout < 1 || waitTimeout > MAX_WAIT_TIMEOUT_SECONDS) {
+      const error = new Error(`--wait-timeout-seconds must be an integer between 1 and ${MAX_WAIT_TIMEOUT_SECONDS}.`);
+      error.type = "validation";
+      throw error;
+    }
+    if (!waitImplied && !ctx.bool("wait") && output === void 0) {
+      const error = new Error("--wait-timeout-seconds requires --wait or --output.");
+      error.type = "validation";
+      throw error;
+    }
+  }
+}
+function clientWaitTimeoutSeconds(ctx) {
+  return optionalContextNumber(ctx, "wait-timeout-seconds") ?? DEFAULT_WAIT_TIMEOUT_SECONDS;
+}
+function optionalContextNumber(ctx, name) {
+  if (typeof ctx.optionalNum === "function") {
+    return ctx.optionalNum(name);
+  }
+  const raw = ctx.str(name);
+  return raw.trim() === "" ? void 0 : Number(raw);
+}
+async function assertOutputPathAvailable(output, force = false, meta = {}) {
+  const outputPath = resolve(output);
+  if (force || !await pathExists(outputPath)) return;
+  throw new CapabilityGatewayError(
+    `Output path already exists: ${outputPath}`,
+    "OUTPUT_ALREADY_EXISTS",
+    409,
+    "Choose another --output path or pass --force to replace the existing file.",
+    { ...meta, output_path: outputPath }
+  );
+}
+async function withInterruptSignal(operation, runId) {
+  const controller = new AbortController();
+  const onInterrupt = () => controller.abort();
+  process.once("SIGINT", onInterrupt);
+  try {
+    return await operation(controller.signal);
+  } catch (error) {
+    if (controller.signal.aborted) throw interruptedError(runId);
+    throw error;
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+async function inspectAnalysisRun(host, runId) {
+  return asDescriptor(await requestCapabilityGateway(
+    host,
+    resolveGatewayDomain("analysis"),
+    `runs/${encodeURIComponent(runId)}`
+  ));
+}
+function ensureCompletedDescriptor(descriptor, runId, artifactId) {
+  const actualArtifactId = descriptorArtifactId(descriptor);
+  if (actualArtifactId && actualArtifactId !== artifactId) {
+    throw new CapabilityGatewayError(
+      `artifact_id ${artifactId} does not belong to run_id ${runId}`,
+      "ARTIFACT_RUN_MISMATCH",
+      400,
+      "Use the run_id and artifact_id pair from the same export response."
+    );
+  }
+  const runStatus = descriptorRunStatus(descriptor);
+  const artifactStatus = normalizedStatus(descriptor.artifact_status ?? descriptor.artifact?.status);
+  if (runStatus === "SUCCEEDED" && artifactStatus === "COMPLETED") return;
+  if (runStatus === "FAILED" || runStatus === "CANCELED" || artifactStatus === "FAILED" || artifactStatus === "CANCELED") {
+    throw terminalError(descriptor, runId, "Artifact cannot be downloaded because the remote lifecycle failed.");
+  }
+  throw new CapabilityGatewayError(
+    `Artifact is not ready: run_status=${runStatus || "UNKNOWN"}, artifact_status=${artifactStatus || "UNKNOWN"}`,
+    "ARTIFACT_NOT_READY",
+    409,
+    `Resume with: ae-cli analysis run wait --run-id ${runId}`,
+    { run_id: runId, artifact_id: artifactId }
+  );
+}
+function descriptorArtifactId(descriptor) {
+  return nonEmptyString(descriptor.artifact_id) ?? nonEmptyString(descriptor.artifact?.artifact_id) ?? nonEmptyString(descriptor.artifact?.id);
+}
+function descriptorRunStatus(descriptor) {
+  return normalizedStatus(descriptor.status ?? descriptor.run_status);
+}
+function deriveDeadline(descriptor, fallbackFrom) {
+  const declaredDeadline = timestampMillis(descriptor?.deadline_at);
+  if (declaredDeadline !== void 0) return declaredDeadline + MATERIALIZATION_GRACE_MS;
+  const expiresAt = timestampMillis(descriptor?.expires_at);
+  if (expiresAt !== void 0) return expiresAt;
+  const effectiveTimeout = Number(descriptor?.effective_timeout_seconds);
+  if (Number.isFinite(effectiveTimeout) && effectiveTimeout > 0) {
+    return fallbackFrom + effectiveTimeout * 1e3 + MATERIALIZATION_GRACE_MS;
+  }
+  return fallbackFrom + DEFAULT_EFFECTIVE_TIMEOUT_MS + MATERIALIZATION_GRACE_MS;
+}
+function timestampMillis(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value < 1e10 ? value * 1e3 : value;
+  }
+  if (typeof value !== "string" || value.trim() === "") return void 0;
+  const numeric = Number(value);
+  if (Number.isFinite(numeric)) return timestampMillis(numeric);
+  const parsed = Date.parse(value);
+  return Number.isFinite(parsed) ? parsed : void 0;
+}
+function nextDelay(current) {
+  return Math.min(5e3, Math.ceil(current * 1.5));
+}
+function normalizedStatus(value) {
+  return typeof value === "string" && value.trim() ? value.trim().toUpperCase() : void 0;
+}
+function asDescriptor(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw protocolError("Async run response is not an object.");
+  }
+  return value;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function optionalString(ctx, name) {
+  return nonEmptyString(ctx.str(name));
+}
+function terminalError(descriptor, runId, message) {
+  return new CapabilityGatewayError(
+    message,
+    "ASYNC_RUN_TERMINAL_FAILURE",
+    409,
+    `The remote lifecycle is terminal and will not succeed on retry. Inspect details with: ae-cli analysis run inspect --run-id ${runId}`,
+    {
+      run_id: runId,
+      artifact_id: descriptorArtifactId(descriptor),
+      run_status: descriptorRunStatus(descriptor),
+      artifact_status: normalizedStatus(descriptor.artifact_status ?? descriptor.artifact?.status),
+      error: descriptor.error ?? descriptor.artifact?.error ?? descriptor.error_message ?? descriptor.artifact?.error_message
+    }
+  );
+}
+function protocolError(message, runId) {
+  return new CapabilityGatewayError(
+    message,
+    "ASYNC_RUN_PROTOCOL_ERROR",
+    502,
+    runId ? resumeHint(runId) : "Inspect the gateway response and verify the async run contract.",
+    runId ? { run_id: runId } : void 0
+  );
+}
+function waitError(message, code, runId, cause, descriptor, extraMeta = {}) {
+  const resumeCommand = `ae-cli analysis run wait --run-id ${runId}`;
+  const error = new CapabilityGatewayError(
+    message,
+    code,
+    void 0,
+    resumeHint(runId),
+    {
+      run_id: runId,
+      artifact_id: descriptor ? descriptorArtifactId(descriptor) : void 0,
+      run_status: descriptor ? descriptorRunStatus(descriptor) : void 0,
+      artifact_status: descriptor ? normalizedStatus(descriptor.artifact_status ?? descriptor.artifact?.status) : void 0,
+      remote_run_canceled: false,
+      resume_command: resumeCommand,
+      ...extraMeta
+    }
+  );
+  if (cause !== void 0) error.cause = cause;
+  return error;
+}
+function interruptedError(runId) {
+  return waitError(
+    `Stopped waiting for run ${runId}. The remote run was not canceled.`,
+    "ASYNC_WAIT_INTERRUPTED",
+    runId
+  );
+}
+function resumeHint(runId) {
+  return `Resume with: ae-cli analysis run wait --run-id ${runId}`;
+}
+function announceSubmitted(runId, artifactId) {
+  process.stderr.write(
+    `[ae-cli] async run submitted run_id=${runId} artifact_id=${artifactId}; ${resumeHint(runId)}
+`
+  );
+}
+function isTransientPollError(error) {
+  if (error instanceof CapabilityGatewayError) {
+    return error.httpStatus === 429 || error.httpStatus !== void 0 && error.httpStatus >= 500;
+  }
+  return error instanceof TypeError || error instanceof Error && /fetch|network|socket|timeout/i.test(error.message);
+}
+function throwIfAborted(signal, runId) {
+  if (signal?.aborted) throw interruptedError(runId);
+}
+async function abortableSleep(milliseconds, signal) {
+  if (milliseconds <= 0) return;
+  await new Promise((resolveSleep, reject) => {
+    let timer;
+    const finish = () => {
+      signal?.removeEventListener("abort", onAbort);
+      resolveSleep();
+    };
+    const onAbort = () => {
+      if (timer !== void 0) clearTimeout(timer);
+      signal?.removeEventListener("abort", onAbort);
+      reject(new DOMException("The operation was aborted", "AbortError"));
+    };
+    if (signal?.aborted) return onAbort();
+    signal?.addEventListener("abort", onAbort, { once: true });
+    timer = setTimeout(finish, milliseconds);
+  });
+}
+async function pathExists(path) {
+  try {
+    await access(path);
+    return true;
+  } catch (error) {
+    if (error?.code === "ENOENT") return false;
+    throw error;
+  }
+}
+function artifactPath(runId, artifactId) {
+  return `runs/${encodeURIComponent(runId)}/artifacts/${encodeURIComponent(artifactId)}/download`;
+}
+function fetchArtifact(host, runId, artifactId) {
+  return fetchCapabilityGateway(
+    host,
+    resolveGatewayDomain("analysis"),
+    artifactPath(runId, artifactId),
+    "GET",
+    void 0,
+    "application/octet-stream"
+  );
+}
+
+export {
+  withAsyncArtifactLifecycle,
+  waitForAnalysisRun,
+  downloadAnalysisArtifact,
+  validateLifecycleFlags,
+  clientWaitTimeoutSeconds,
+  assertOutputPathAvailable,
+  withInterruptSignal
+};

package/dist/{chunk-YTG6Q75E.js → chunk-WZRX4KOH.js}

@@ -1,15 +1,15 @@
 import {
   peekCliToken
-} from "./chunk-Z3OXWCIA.js";
+} from "./chunk-S5NTSDBS.js";
 import {
   getToken
-} from "./chunk-YV52FB5G.js";
+} from "./chunk-ZQKDZXDO.js";
 import {
   getActiveHost,
   getConfigDir,
   isAeSandboxRuntime,
   normalizeUrl
-} from "./chunk-GJJA4CQZ.js";
+} from "./chunk-3FY3RJ26.js";
 import {
   logger
 } from "./chunk-JHENBQ5B.js";
@@ -905,6 +905,12 @@ function withOutputMetadata(data, meta) {
 function isOutputWithMetadata(value) {
   return Boolean(value?.[OUTPUT_METADATA]);
 }
+function unwrapOutputData(value) {
+  return isOutputWithMetadata(value) ? value.data : value;
+}
+function readOutputMetadata(value) {
+  return isOutputWithMetadata(value) ? value.meta : void 0;
+}
 function findArrayField(data) {
   if (Array.isArray(data)) return data;
   if (typeof data !== "object" || data === null) return null;
@@ -917,6 +923,20 @@ function findArrayField(data) {
   return null;
 }
 function formatTable(data) {
+  if (Array.isArray(data?.title) && data.title.length > 0 && Array.isArray(data?.rows)) {
+    const headers = data.title.map((value) => String(value));
+    const table2 = new Table({ head: headers, wordWrap: true });
+    for (const row of data.rows) {
+      const values = Array.isArray(row) ? row : [row];
+      table2.push(headers.map((_, index) => {
+        const value = values[index];
+        if (value === void 0 || value === null) return "";
+        if (typeof value === "object") return JSON.stringify(value);
+        return String(value);
+      }));
+    }
+    return table2.toString();
+  }
   const rows = findArrayField(data);
   if (!rows || rows.length === 0) {
     return JSON.stringify(data, null, 2);
@@ -1011,6 +1031,8 @@ export {
   formatCapabilityMissCompatHint,
   runHostCompatCheck,
   withOutputMetadata,
+  unwrapOutputData,
+  readOutputMetadata,
   printError,
   printOutput
 };

package/dist/{chunk-YV52FB5G.js → chunk-ZQKDZXDO.js}

@@ -3,7 +3,7 @@ import {
   getConfigDir,
   normalizeUrl,
   safeJsonParse
-} from "./chunk-GJJA4CQZ.js";
+} from "./chunk-3FY3RJ26.js";
 import {
   logger
 } from "./chunk-JHENBQ5B.js";

package/dist/{cli-token-GL5MS5FK.js → cli-token-4UPER74P.js}

@@ -6,9 +6,9 @@ import {
   mintCliToken,
   peekCliToken,
   setCliTokenManual
-} from "./chunk-Z3OXWCIA.js";
-import "./chunk-YV52FB5G.js";
-import "./chunk-GJJA4CQZ.js";
+} from "./chunk-S5NTSDBS.js";
+import "./chunk-ZQKDZXDO.js";
+import "./chunk-3FY3RJ26.js";
 import "./chunk-JHENBQ5B.js";
 export {
   _resetRenewMemoryForTest,

package/dist/{chunk-6A2FUCIS.js → client-L2YDMHQ6.js}

@@ -3,10 +3,10 @@ import {
   getToken,
   invalidateAccessTokenForRetry,
   resolveHost
-} from "./chunk-YV52FB5G.js";
+} from "./chunk-ZQKDZXDO.js";
 import {
   safeJsonParse
-} from "./chunk-GJJA4CQZ.js";
+} from "./chunk-3FY3RJ26.js";
 import {
   logger
 } from "./chunk-JHENBQ5B.js";
@@ -191,14 +191,13 @@ async function queryReportData(projectId, reportId, qp, eventModel, options = {}
     ...options
   }, hostUrl);
 }
-
 export {
+  httpDelete,
   httpGet,
   httpPost,
   httpRequest,
-  httpDelete,
   httpUpload,
-  wsQuery,
+  queryReportData,
   querySql,
-  queryReportData
+  wsQuery
 };