@get-dx/cli 0.6.1 → 0.6.2

package/dist/commandHelpers.js

@@ -58,7 +58,7 @@ export function handleError(error, command, argv) {
     }
     else {
         if (error instanceof HttpError) {
-            process.stderr.write(pc.red(`The API returned an error with status code ${error.status}:\n\n${JSON.stringify(error.body, null, 2)}\n`));
+            process.stderr.write(pc.red(formatHttpError(error)));
         }
         else if (error instanceof CommanderError &&
             (error.code === "commander.help" || error.message === "(outputHelp)")) {
@@ -82,6 +82,39 @@ export function handleError(error, command, argv) {
     })();
     process.exit(exitCode);
 }
+/**
+ * `status` and `body` are only populated when the API actually answered.
+ * Network, TLS, and non-JSON failures carry their detail in `message` alone, so
+ * these helpers coalesce so we display full details.
+ */
+function formatHttpError(error) {
+    const heading = formatHttpErrorHeading(error);
+    const body = formatHttpErrorBody(error.body);
+    return body === null ? `${heading}\n` : `${heading}\n\n${body}\n`;
+}
+function formatHttpErrorHeading(error) {
+    if (error.status === undefined) {
+        return error.message;
+    }
+    // A successful or redirect status that still failed the request — an
+    // unparseable body, or a redirect missing its Location — isn't an error the
+    // API reported, so don't describe it as one.
+    if (error.status < 400) {
+        return `${error.message} (HTTP ${error.status})`;
+    }
+    return `The API returned an error with status code ${error.status}: ${error.message}`;
+}
+function formatHttpErrorBody(body) {
+    if (body === undefined || body === "") {
+        return null;
+    }
+    // Non-JSON bodies (proxy block pages, HTML error pages) are far more legible
+    // raw than as a JSON string literal full of escaped newlines.
+    if (typeof body === "string") {
+        return body;
+    }
+    return JSON.stringify(body, null, 2) ?? String(body);
+}
 function printJson(value) {
     process.stdout.write(JSON.stringify(value, null, 2) + "\n");
 }

package/dist/commands/studio/query.js

@@ -4,7 +4,7 @@ import path from "node:path";
 import { Command } from "commander";
 import { createExampleText, getContext, wrapAction, } from "../../commandHelpers.js";
 import { CliError, EXIT_CODES, HttpError } from "../../errors.js";
-import { request } from "../../http.js";
+import { describeFetchFailure, request } from "../../http.js";
 import { AsyncProgressReporter, renderJson, renderRichText, } from "../../renderers.js";
 import { buildRuntime } from "../../runtime.js";
 import * as ui from "../../ui.js";
@@ -197,7 +197,7 @@ async function fetchResponse(url, init) {
         response = await fetch(url, init);
     }
     catch (error) {
-        throw new HttpError(`Request failed: ${error.message}`);
+        throw new HttpError(`Could not reach ${url}: ${describeFetchFailure(error)}`);
     }
     return response;
 }

package/dist/http.js

@@ -43,7 +43,7 @@ export async function request(runtime, route, options = {}) {
         });
     }
     catch (error) {
-        throw new HttpError(`Request failed: ${error.message}`);
+        throw new HttpError(`Could not reach ${url}: ${describeFetchFailure(error)}`);
     }
     const responseBodyText = await response.text();
     const parsedResponseBody = parseResponseBody(responseBodyText);
@@ -61,12 +61,42 @@ export async function request(runtime, route, options = {}) {
     }
     if (typeof parsedResponseBody === "string" &&
         parsedResponseBody === responseBodyText) {
-        throw new HttpError("Invalid JSON response: Unexpected token");
+        // A 2xx that isn't JSON usually means something other than the API answered
+        // e.g. a proxy block page, a captive portal, etc. Pass the status
+        // and the raw text along so the user can see what actually came back.
+        throw new HttpError(responseBodyText
+            ? `Invalid JSON response from ${url}`
+            : `Empty response body from ${url}`, response.status, responseBodyText);
     }
     const retryAfterMs = parseRetryAfterMs(response.headers);
     const body = parsedResponseBody;
     return retryAfterMs === undefined ? { body } : { body, retryAfterMs };
 }
+/**
+ * Flatten an error thrown by `fetch` into a single readable message.
+ *
+ * Node reports every DNS, proxy, and TLS failure as `TypeError: fetch failed`
+ * and hangs the real reason off `cause`, so the top-level message alone can't
+ * distinguish an untrusted corporate root certificate from an unreachable host.
+ */
+export function describeFetchFailure(error) {
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    const parts = [];
+    let current = error;
+    while (current instanceof Error) {
+        const { code } = current;
+        const part = code ? `${current.message} (${code})` : current.message;
+        if (!parts.includes(part)) {
+            parts.push(part);
+        }
+        current = current.cause;
+    }
+    // "fetch failed" carries no information once a cause is available.
+    const informative = parts.filter((part) => parts.length === 1 || part !== "fetch failed");
+    return informative.join(": ");
+}
 export function parseRetryAfterMs(headers) {
     const retryAfter = headers.get("retry-after");
     if (!retryAfter) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@get-dx/cli",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "DX CLI",
   "author": "DX <developers@getdx.com>",
   "bugs": {