@moda-ai/cli 1.55.9 → 1.55.11

package/dist/{cli-fhfdnvh4.js → cli-n9gexgma.js}

@@ -1,7 +1,7 @@
 import {
   authFetch,
   getCachedLoginContext
-} from "./cli-tw8jj190.js";
+} from "./cli-t4jjhn3g.js";
 import {
   CliAccessError,
   CliInputError,
@@ -16,7 +16,7 @@ import {
   resolveTenantIdFromActiveProfile,
   saveCliConfig,
   writeSecretJsonFile
-} from "./cli-mx9r1689.js";
+} from "./cli-429zt7g4.js";
 
 // src/init/tenant.ts
 import { randomUUID } from "node:crypto";

package/dist/{cli-tw8jj190.js → cli-t4jjhn3g.js}

@@ -8,7 +8,7 @@ import {
   saveProfileConfig,
   secretFilePathFromRef,
   writeSecretJsonFile
-} from "./cli-mx9r1689.js";
+} from "./cli-429zt7g4.js";
 import {
   __require
 } from "./cli-0v6na3yp.js";
@@ -157,12 +157,6 @@ function clearAuthSession(options = {}) {
   rmSync(tokenPath(options), { force: true });
 }
 
-// src/auth.ts
-import { createServer } from "node:http";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
-import { hostname } from "node:os";
-import { createInterface } from "node:readline";
-
 // src/cli-session.ts
 import { request as httpRequest } from "node:http";
 import { request as httpsRequest } from "node:https";
@@ -270,6 +264,10 @@ async function revokeCliSessionToken(options = {}) {
 }
 
 // src/auth.ts
+import { createServer } from "node:http";
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { hostname } from "node:os";
+import { createInterface } from "node:readline";
 var CALLBACK_PORT = 8432;
 var CALLBACK_PORT_LADDER = [CALLBACK_PORT, 8433, 8434, 8435];
 var DEFAULT_AUTH_TIMEOUT_MS = 600000;

package/dist/cli-tmqd1f0m.js

@@ -0,0 +1,159 @@
+import {
+  apiKeyHeaders
+} from "./cli-m16taf4z.js";
+import {
+  recordApiRequest,
+  resolveApiKey,
+  resolveModaBaseUrl
+} from "./cli-429zt7g4.js";
+
+// src/api-client.ts
+var REQUEST_TIMEOUT_MS = 30000;
+var MAX_RETRIES = 3;
+var INITIAL_BACKOFF_MS = 500;
+var NETWORK_RETRY_DELAY_MS = 1000;
+
+class ApiError extends Error {
+  statusCode;
+  responseBody;
+  code;
+  suggestions;
+  readable;
+  constructor(message, statusCode, responseBody) {
+    const typed = parseTypedErrorBody(responseBody);
+    const platform = platformFailure(responseBody);
+    const readable = typed?.code === "audit_too_large" || platform !== null;
+    super(readable ? `API error (${statusCode}): ${typed?.message ?? platform?.message}` : message);
+    this.statusCode = statusCode;
+    this.responseBody = responseBody;
+    this.name = "ApiError";
+    this.code = typed?.code ?? platform?.code;
+    this.suggestions = typed?.suggestions;
+    this.readable = readable;
+  }
+}
+function parseTypedErrorBody(body) {
+  if (!body.trimStart().startsWith("{"))
+    return null;
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed.code !== "string")
+      return null;
+    const suggestions = Array.isArray(parsed.suggestions) ? parsed.suggestions.filter((s) => typeof s === "string") : undefined;
+    return {
+      code: parsed.code,
+      message: typeof parsed.message === "string" ? parsed.message : undefined,
+      suggestions
+    };
+  } catch {
+    return null;
+  }
+}
+var DETERMINISTIC_PLATFORM_FAILURES = [
+  "FUNCTION_INVOCATION_FAILED",
+  "FUNCTION_RESPONSE_PAYLOAD_TOO_LARGE"
+];
+function platformFailure(body) {
+  const code = DETERMINISTIC_PLATFORM_FAILURES.find((c) => body.includes(c));
+  if (!code)
+    return null;
+  const requestId = /\b([a-z]{3}\d::[A-Za-z0-9:-]+)/.exec(body)?.[1];
+  const cause = code === "FUNCTION_RESPONSE_PAYLOAD_TOO_LARGE" ? "the response was larger than the hosting platform allows" : "the server function crashed (typically out of memory or an oversized response)";
+  return {
+    code,
+    message: `The Moda API could not complete this request: ${cause} [${code}` + `${requestId ? `, request ${requestId}` : ""}]. Retrying the same request will fail the same way; ` + "narrow it (a smaller --limit, a single trace, or fewer results) and report it with `moda feedback` if it persists."
+  };
+}
+function isRetryableResponse(status, body) {
+  if (!isRetryable(status))
+    return false;
+  return platformFailure(body) === null;
+}
+
+class NetworkError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "NetworkError";
+  }
+}
+function networkErrorMessage(error, url) {
+  const message = error instanceof Error ? error.message : String(error);
+  const cause = error instanceof Error ? error.cause : undefined;
+  const code = typeof cause?.code === "string" ? `: ${cause.code}` : "";
+  return `Network error: ${message} (could not reach ${url.split("?")[0]}${code})`;
+}
+function isRetryable(status) {
+  return status === 429 || status >= 500;
+}
+async function callDataAPI(endpoint, init = { method: "GET" }, requestOptions = {}) {
+  const url = `${resolveModaBaseUrl()}/api/v1/data${endpoint}`;
+  return callModaAPI(url, init, {}, requestOptions);
+}
+async function callControlAPI(endpoint, options = {}, profileOptions = {}, requestOptions = {}) {
+  const url = `${resolveModaBaseUrl(profileOptions)}/api${endpoint}`;
+  return callModaAPI(url, options, profileOptions, requestOptions);
+}
+async function callModaAPI(url, options, profileOptions = {}, requestOptions = {}) {
+  const timeoutMs = requestOptions.timeoutMs ?? REQUEST_TIMEOUT_MS;
+  const method = (options.method ?? "GET").toUpperCase();
+  const maxRetries = requestOptions.retries ?? (method === "GET" || method === "HEAD" ? MAX_RETRIES : 0);
+  const initialNetworkRetryBudget = requestOptions.retryOnceOnNetworkError ? 1 : 0;
+  let networkRetryBudget = initialNetworkRetryBudget;
+  let connectionClose = false;
+  const maxAttempts = maxRetries + initialNetworkRetryBudget + 1;
+  for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    if (attempt > 0) {
+      const backoff = connectionClose ? requestOptions.networkRetryDelayMs ?? NETWORK_RETRY_DELAY_MS : INITIAL_BACKOFF_MS * Math.pow(2, attempt - 1);
+      await new Promise((resolve) => setTimeout(resolve, backoff));
+    }
+    const controller = new AbortController;
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+      recordApiRequest();
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...apiKeyHeaders(resolveApiKey(profileOptions) ?? "", profileOptions, url),
+          "Content-Type": "application/json",
+          ...options.headers ?? {},
+          ...connectionClose ? { Connection: "close" } : {}
+        },
+        signal: controller.signal
+      });
+      if (!response.ok) {
+        const errorText = await response.text();
+        const error = new ApiError(`API error (${response.status}): ${errorText}`, response.status, errorText);
+        if (isRetryableResponse(response.status, errorText) && attempt < maxRetries) {
+          continue;
+        }
+        throw error;
+      }
+      if (response.status === 204)
+        return null;
+      if (typeof response.text !== "function")
+        return response.json();
+      const text = await response.text();
+      return text.trim() === "" ? null : JSON.parse(text);
+    } catch (error) {
+      if (error instanceof ApiError)
+        throw error;
+      const isAbort = error instanceof DOMException && error.name === "AbortError";
+      const wrapped = isAbort ? new Error(`Request timed out after ${timeoutMs}ms: ${url}`) : new NetworkError(networkErrorMessage(error, url));
+      if (attempt < maxRetries) {
+        continue;
+      }
+      if (!isAbort && networkRetryBudget > 0) {
+        networkRetryBudget -= 1;
+        connectionClose = true;
+        requestOptions.onNetworkRetry?.();
+        continue;
+      }
+      throw wrapped;
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  throw new NetworkError(`Request retries exhausted: ${url}`);
+}
+
+export { ApiError, callDataAPI, callControlAPI };