@devicecloud.dev/dcd 5.8.0 → 5.9.0-beta.1

package/dist/services/report-download.service.js

@@ -8,7 +8,7 @@ export class ReportDownloadService {
     /**
      * Download test artifacts as a zip file
      * @param options Download configuration
-     * @returns Promise that resolves when download is complete
+     * @returns What the download did
      */
     async downloadArtifacts(options) {
         const { apiUrl, auth, uploadId, downloadType, artifactsPath = './artifacts.zip', debug = false, logger, warnLogger, } = options;
@@ -23,53 +23,53 @@ export class ReportDownloadService {
                 logger('\n');
                 logger(`Test artifacts have been downloaded to ${artifactsPath}`);
             }
+            return { ok: true, path: artifactsPath, type: 'artifacts' };
         }
         catch (error) {
             if (debug && logger) {
                 logger(`[DEBUG] Error downloading artifacts: ${error}`);
             }
             this.warnDownloadFailure(warnLogger, 'artifacts', 'No artifacts found for this upload. Make sure your tests generated results.', error);
+            return { error: errorText(error), ok: false, path: artifactsPath, type: 'artifacts' };
         }
     }
     /**
      * Handle downloading reports based on the report type specified
      * @param options Report download configuration
-     * @returns Promise that resolves when download is complete
+     * @returns What the download did, or undefined for an unknown report type
      */
     async downloadReports(options) {
         const { reportType, junitPath, allurePath, htmlPath, warnLogger, ...downloadOptions } = options;
         switch (reportType) {
             case 'junit': {
                 const reportPath = path.resolve(process.cwd(), junitPath || 'report.xml');
-                await this.downloadReport('junit', reportPath, {
+                return this.downloadReport('junit', reportPath, {
                     ...downloadOptions,
                     warnLogger,
                 });
-                break;
             }
             case 'allure': {
                 const reportPath = path.resolve(process.cwd(), allurePath || 'report.html');
-                await this.downloadReport('allure', reportPath, {
+                return this.downloadReport('allure', reportPath, {
                     ...downloadOptions,
                     warnLogger,
                 });
-                break;
             }
             case 'html':
             case 'html-detailed': {
                 // The HTML report is a ZIP (report.html plus its screenshots and
                 // assets), so the default name says so. An explicit path is kept as-is.
                 const htmlReportPath = path.resolve(process.cwd(), htmlPath || 'report.zip');
-                await this.downloadReport('html', htmlReportPath, {
+                return this.downloadReport('html', htmlReportPath, {
                     ...downloadOptions,
                     warnLogger,
                 });
-                break;
             }
             default: {
                 if (warnLogger) {
                     warnLogger(`Unknown report type: ${reportType}`);
                 }
+                return undefined;
             }
         }
     }
@@ -78,7 +78,7 @@ export class ReportDownloadService {
      * @param type Report type to download
      * @param filePath Path where report should be saved
      * @param options Download configuration
-     * @returns Promise that resolves when download is complete
+     * @returns What the download did
      */
     async downloadReport(type, filePath, options) {
         const { apiUrl, auth, uploadId, debug = false, logger, warnLogger } = options;
@@ -91,12 +91,14 @@ export class ReportDownloadService {
             if (logger) {
                 logger(`${type.toUpperCase()} test report has been downloaded to ${filePath}`);
             }
+            return { ok: true, path: filePath, type };
         }
         catch (error) {
             if (debug && logger) {
                 logger(`[DEBUG] Error downloading ${type.toUpperCase()} report: ${error}`);
             }
             this.warnDownloadFailure(warnLogger, `${type.toUpperCase()} report`, `No ${type.toUpperCase()} reports found for this upload. Make sure your tests generated results.`, error);
+            return { error: errorText(error), ok: false, path: filePath, type };
         }
     }
     /**
@@ -112,7 +114,7 @@ export class ReportDownloadService {
         if (!warnLogger) {
             return;
         }
-        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorMessage = errorText(error);
         warnLogger(`Failed to download ${subject}: ${errorMessage}`);
         if (errorMessage.includes('404')) {
             warnLogger(notFoundHint);
@@ -125,3 +127,6 @@ export class ReportDownloadService {
         }
     }
 }
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/utils/ci.d.ts

@@ -10,6 +10,15 @@
  * counts — providers set `CI=true`, but a bare presence check is the safe net.
  */
 export declare function isCI(): boolean;
+/**
+ * Whether a prompt drawn on `output` can be answered: stdin and `output` must
+ * both be terminals. Without that (a script, CI, a shell an agent runs) a clack
+ * prompt waits for a keypress that never comes. Unlike isCI(), CI env vars
+ * don't count: a terminal with `CI=true` exported can still answer a prompt.
+ */
+export declare function canPrompt(output?: {
+    isTTY?: boolean;
+}): boolean;
 /** Which DCD CI integration (if any) is wrapping this CLI invocation, and its version. */
 export interface CiContext {
     /** e.g. 'github' | 'bitrise' | 'bitbucket' | 'eas' | 'gitlab' | 'circleci'. */

package/dist/utils/ci.js

@@ -37,6 +37,15 @@ export function isCI() {
     }
     return !process.stdout.isTTY;
 }
+/**
+ * Whether a prompt drawn on `output` can be answered: stdin and `output` must
+ * both be terminals. Without that (a script, CI, a shell an agent runs) a clack
+ * prompt waits for a keypress that never comes. Unlike isCI(), CI env vars
+ * don't count: a terminal with `CI=true` exported can still answer a prompt.
+ */
+export function canPrompt(output = process.stdout) {
+    return process.stdin.isTTY === true && output.isTTY === true;
+}
 /** Infer the CI provider from the env vars each platform sets natively. */
 function inferProvider() {
     const env = process.env;

package/dist/utils/cli.d.ts

@@ -9,13 +9,20 @@ export declare class CliError extends Error {
 export interface Logger {
     log(message: string): void;
     warn(message: string): void;
+    json(value: unknown): void;
     error(message: Error | string, opts?: {
         exit?: number;
         json?: boolean;
     }): never;
     exit(code?: number): never;
+    fail(message: Error | string, exitCode: number): never;
 }
 export declare const logger: Logger;
+/**
+ * Whether the invocation asked for JSON output. Read from raw argv so the
+ * top-level error handler can honour it even when citty never parsed args.
+ */
+export declare function wantsJson(rawArgs: string[]): boolean;
 /**
  * Validate that a string flag value is one of the allowed options.
  * Returns the value untouched on success; throws CliError otherwise.

package/dist/utils/cli.js

@@ -7,6 +7,7 @@
  *   sites ported from oclif keep working.
  */
 import { readFileSync } from 'node:fs';
+import { stripVTControlCharacters } from 'node:util';
 import { telemetry } from '../services/telemetry.service.js';
 import { symbols } from './styling.js';
 // Resolve version at runtime. The bun-compiled binary can't read package.json
@@ -57,13 +58,18 @@ export const logger = {
         // eslint-disable-next-line no-console
         console.warn(symbols.warning + ' ' + message);
     },
+    json(value) {
+        // The one stdout write under --json; everything else is gated off.
+        // eslint-disable-next-line no-console
+        console.log(JSON.stringify(value, null, 2));
+    },
     error(message, opts = {}) {
         const text = message instanceof Error ? message.message : message;
         if (opts.json) {
             // When --json is active, emit failures as JSON on stdout so that
             // scripts consuming the output never need to parse stderr too.
-            // eslint-disable-next-line no-console
-            console.log(JSON.stringify({ status: 'FAILED', error: text }, null, 2));
+            // citty colours some of its messages; JSON consumers want plain text.
+            logger.json({ status: 'FAILED', error: stripVTControlCharacters(text) });
         }
         else {
             // The literal "Error:" prefix is important for tests and for grep-friendly
@@ -71,18 +77,29 @@ export const logger = {
             // eslint-disable-next-line no-console
             console.error(symbols.error + ' Error: ' + text);
         }
+        return logger.fail(message, opts.exit ?? 1);
+    },
+    exit(code = 0) {
+        process.exit(code);
+    },
+    // Exit as a failure without printing anything — for --json paths that have
+    // already written their result object and must not print a second one.
+    fail(message, exitCode) {
         // process.exit bypasses beforeExit, so async fetch in telemetry.flush()
         // would be killed mid-flight. flushSync uses curl to ship synchronously
         // before we exit; it's a no-op if telemetry never reached configure().
-        const exitCode = opts.exit ?? 1;
         telemetry.recordCommandFailure({ error: message, exitCode });
         telemetry.flushSync();
         process.exit(exitCode);
     },
-    exit(code = 0) {
-        process.exit(code);
-    },
 };
+/**
+ * Whether the invocation asked for JSON output. Read from raw argv so the
+ * top-level error handler can honour it even when citty never parsed args.
+ */
+export function wantsJson(rawArgs) {
+    return rawArgs.some((a) => a === '--json' || a === '--json=true');
+}
 /**
  * Validate that a string flag value is one of the allowed options.
  * Returns the value untouched on success; throws CliError otherwise.

package/dist/utils/orgs.d.ts

@@ -1,11 +1,48 @@
+import type { Readable, Writable } from 'node:stream';
 export interface OrgListItem {
     id: string;
     name: string;
     slug?: string;
 }
 export declare function fetchOrgs(apiUrl: string, headers: Record<string, string>): Promise<OrgListItem[]>;
+/**
+ * Match a user-supplied string to an org. Prefers case-insensitive name match.
+ * Falls back to slug / id so existing scripts keep working, but error output
+ * only surfaces names. `pickCommand` is how to pick interactively instead,
+ * for when two orgs share a name.
+ */
+export declare function matchOrg(orgs: OrgListItem[], target: string, pickCommand: string): OrgListItem;
+export interface PickOrgOptions {
+    message?: string;
+    /** Org to start the picker on, so Enter confirms it. Ignored if not listed. */
+    initialId?: string;
+    input?: Readable;
+    output?: Writable;
+}
 /**
  * Interactive org picker. Auto-selects when there's only one org (returns it
  * without prompting). Throws on zero orgs or user cancellation.
  */
-export declare function pickOrg(orgs: OrgListItem[], message?: string): Promise<OrgListItem>;
+export declare function pickOrg(orgs: OrgListItem[], { message, initialId, input, output, }?: PickOrgOptions): Promise<OrgListItem>;
+export interface SelectOrgOptions {
+    /** `dcd login --org`: a name, slug or id. Skips the picker. */
+    requested?: string;
+    /** The org the last login chose. */
+    lastOrgId?: string;
+    /** Whether anyone can answer the picker (see canPrompt). */
+    interactive: boolean;
+    input?: Readable;
+    output?: Writable;
+}
+/**
+ * Choose the org for `dcd login`: `--org` if given, else the only org, else
+ * the picker starting on the last login's org. Without a TTY nobody can
+ * answer the picker, so the last login's org is used without asking, and
+ * when there isn't one the error names `--org` instead of hanging.
+ * `fromLastLogin` is set when that fallback chose the org, so the caller
+ * can say so.
+ */
+export declare function selectOrg(orgs: OrgListItem[], { requested, lastOrgId, interactive, input, output }: SelectOrgOptions): Promise<{
+    org: OrgListItem;
+    fromLastLogin: boolean;
+}>;

package/dist/utils/orgs.js

@@ -1,6 +1,6 @@
 /**
- * Shared helpers for fetching and picking from /me/orgs. Used by both
- * `dcd login` (after the PKCE claim returns a session) and `dcd switch-org`.
+ * Shared helpers for fetching, matching and picking from /me/orgs. Used by
+ * both `dcd login` (after the PKCE claim returns a session) and `dcd switch-org`.
  */
 import * as p from '@clack/prompts';
 import { CliError } from './cli.js';
@@ -13,11 +13,29 @@ export async function fetchOrgs(apiUrl, headers) {
     const body = (await res.json());
     return body.orgs ?? [];
 }
+/**
+ * Match a user-supplied string to an org. Prefers case-insensitive name match.
+ * Falls back to slug / id so existing scripts keep working, but error output
+ * only surfaces names. `pickCommand` is how to pick interactively instead,
+ * for when two orgs share a name.
+ */
+export function matchOrg(orgs, target, pickCommand) {
+    const needle = target.toLowerCase();
+    const nameMatches = orgs.filter((o) => o.name.toLowerCase() === needle);
+    if (nameMatches.length > 1) {
+        throw new CliError(`Multiple orgs named "${target}". Run ${pickCommand} to pick interactively.`);
+    }
+    const chosen = nameMatches[0] ?? orgs.find((o) => o.slug === target || o.id === target);
+    if (!chosen) {
+        throw new CliError(`No org named "${target}". Available: ${orgs.map((o) => o.name).join(', ')}`);
+    }
+    return chosen;
+}
 /**
  * Interactive org picker. Auto-selects when there's only one org (returns it
  * without prompting). Throws on zero orgs or user cancellation.
  */
-export async function pickOrg(orgs, message = 'Pick an organization') {
+export async function pickOrg(orgs, { message = 'Pick an organization', initialId, input, output, } = {}) {
     if (orgs.length === 0) {
         throw new CliError('No organizations found for this user.');
     }
@@ -25,7 +43,11 @@ export async function pickOrg(orgs, message = 'Pick an organization') {
         return orgs[0];
     const picked = await p.select({
         message,
+        input,
+        output,
         options: orgs.map((o) => ({ value: o.id, label: o.name })),
+        // clack starts on the first option when this isn't one of them.
+        initialValue: initialId,
     });
     if (p.isCancel(picked))
         throw new CliError('Cancelled.');
@@ -34,3 +56,37 @@ export async function pickOrg(orgs, message = 'Pick an organization') {
         throw new CliError('No organization selected.');
     return chosen;
 }
+/**
+ * Choose the org for `dcd login`: `--org` if given, else the only org, else
+ * the picker starting on the last login's org. Without a TTY nobody can
+ * answer the picker, so the last login's org is used without asking, and
+ * when there isn't one the error names `--org` instead of hanging.
+ * `fromLastLogin` is set when that fallback chose the org, so the caller
+ * can say so.
+ */
+export async function selectOrg(orgs, { requested, lastOrgId, interactive, input, output }) {
+    if (orgs.length === 0) {
+        throw new CliError('No organizations found for this user.');
+    }
+    if (requested !== undefined) {
+        return {
+            org: matchOrg(orgs, requested, '`dcd login` without --org'),
+            fromLastLogin: false,
+        };
+    }
+    if (orgs.length === 1)
+        return { org: orgs[0], fromLastLogin: false };
+    if (!interactive) {
+        const last = orgs.find((o) => o.id === lastOrgId);
+        if (last)
+            return { org: last, fromLastLogin: true };
+        const reason = lastOrgId
+            ? "The organization from your last login is no longer available, and there's no terminal to pick another in."
+            : "You belong to more than one organization, and there's no terminal to pick one in.";
+        throw new CliError(`${reason} Run \`dcd login --org <name>\` with one of: ${orgs.map((o) => o.name).join(', ')}`);
+    }
+    return {
+        org: await pickOrg(orgs, { initialId: lastOrgId, input, output }),
+        fromLastLogin: false,
+    };
+}

package/package.json

@@ -30,7 +30,7 @@
     "chai": "^6.2.2",
     "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-unicorn": "^77.0.0",
+    "eslint-plugin-unicorn": "^78.0.0",
     "husky": "^9.1.7",
     "mocha": "^12.0.0",
     "prettier": "^3.8.4",
@@ -68,7 +68,7 @@
     "test:unit": "node scripts/test-runner.mjs --unit",
     "typecheck": "tsc --noEmit -p tsconfig.test.json"
   },
-  "version": "5.8.0",
+  "version": "5.9.0-beta.1",
   "bugs": {
     "url": "https://discord.gg/gm3mJwcNw8"
   },
@@ -110,7 +110,7 @@
       "esbuild@<0.28.1": ">=0.28.1",
       "qs@<6.16.0": "6.16.0",
       "fast-uri@>=3.0.0 <3.1.8": "3.1.8",
-      "hono@>=4.0.0 <4.13.7": "4.13.7",
+      "hono@>=4.0.0 <4.13.11": "4.13.11",
       "source-map-js@<1.2.2": "1.2.2",
       "micromatch>picomatch": "^2.3.2",
       "tinyglobby>picomatch": "^4.0.4"