@get-dx/cli 0.6.0 → 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/commands/studio/reports.js

@@ -367,9 +367,9 @@ function studioReportToYaml(report) {
         description: report.description ?? "",
         markdown_notes: report.markdown_notes ?? "",
         view_access_type: report.view_access_type,
-        viewer_emails: [],
+        viewer_emails: report.viewer_emails ?? [],
         edit_access_type: report.edit_access_type,
-        editor_emails: [],
+        editor_emails: report.editor_emails ?? [],
         tiles: report.tiles.map((tile) => ({
             id: tile.id,
             title: tile.title,

package/dist/config.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { CliError, EXIT_CODES } from "./errors.js";
-const DEFAULT_API_BASE_URL = "https://api.getdx.com";
+export const DEFAULT_API_BASE_URL = "https://api.getdx.com";
 const DEFAULT_WEB_BASE_URL = "https://app.getdx.com";
 // --- Config file I/O ---------------------------------------------------------
 export function getConfigPath() {
@@ -14,7 +14,16 @@ export function readConfig() {
         return {};
     }
     const content = fs.readFileSync(configPath, "utf8");
-    const raw = JSON.parse(content);
+    let raw;
+    try {
+        raw = JSON.parse(content);
+    }
+    catch {
+        // The config file can be left empty or truncated if a previous `dx`
+        // process was killed mid-write, or two processes wrote concurrently.
+        // Treat it like a missing config rather than crashing every command.
+        return {};
+    }
     const stored = {};
     if (typeof raw.webBaseUrl === "string") {
         stored.webBaseUrl = raw.webBaseUrl;
@@ -46,8 +55,15 @@ export function persistVersionPromptSelection(prompt) {
     writeConfig(config);
 }
 export function writeConfig(config) {
-    fs.mkdirSync(getConfigDir(), { recursive: true });
-    fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2) + "\n", "utf8");
+    const configDir = getConfigDir();
+    fs.mkdirSync(configDir, { recursive: true });
+    const configPath = getConfigPath();
+    // Write to a temp file and rename into place so a crash or a race between
+    // concurrent `dx` processes can't leave config.json empty or truncated —
+    // renames are atomic, so readers always see either the old or new content.
+    const tempPath = path.join(configDir, `.config.json.${process.pid}.${Date.now()}.tmp`);
+    fs.writeFileSync(tempPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+    fs.renameSync(tempPath, configPath);
 }
 export function persistBaseUrls(apiBaseUrl, webBaseUrl) {
     writeConfig({

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/dist/loginViaBrowser.js

@@ -49,7 +49,16 @@ export async function loginViaBrowser(webBaseUrl) {
                 error: new CliError(`Authentication failed: token exchange failed with status ${tokenExchangeResponse.status}`),
             };
         }
-        const body = (await tokenExchangeResponse.json());
+        let body;
+        try {
+            body = (await tokenExchangeResponse.json());
+        }
+        catch {
+            return {
+                type: "ERROR",
+                error: new CliError("Authentication failed: token exchange returned an invalid response"),
+            };
+        }
         return {
             type: "SUCCESS",
             token: body.access_token,

package/package.json

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