@devicecloud.dev/dcd 4.4.9 → 5.0.0-beta.1

package/dist/utils/config-store.js

@@ -0,0 +1,115 @@
+/**
+ * Persistent CLI config: Supabase session tokens + chosen org.
+ *
+ * Storage: $XDG_CONFIG_HOME/dcd/config.json (fallback ~/.dcd/config.json).
+ * File mode 0600, directory mode 0700 — owner-only.
+ * Writes are atomic (tmp file + rename) so a crash mid-refresh can't
+ * leave a corrupt config behind that logs the user out.
+ */
+import { randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { homedir } from 'node:os';
+import * as path from 'node:path';
+import { ENVIRONMENTS } from '../config/environments.js';
+export const CONFIG_SCHEMA_VERSION = 1;
+export function getConfigDir() {
+    if (process.env.DCD_CONFIG_DIR)
+        return process.env.DCD_CONFIG_DIR;
+    const xdg = process.env.XDG_CONFIG_HOME;
+    if (xdg && xdg.trim().length > 0)
+        return path.join(xdg, 'dcd');
+    return path.join(homedir(), '.dcd');
+}
+export function getConfigPath() {
+    return path.join(getConfigDir(), 'config.json');
+}
+export function readConfig() {
+    const p = getConfigPath();
+    if (!existsSync(p))
+        return null;
+    try {
+        const raw = readFileSync(p, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed.version !== CONFIG_SCHEMA_VERSION) {
+            // eslint-disable-next-line no-console
+            console.warn(`Warning: config at ${p} was written by an incompatible CLI version (config version ${parsed.version}); ignoring it. Run \`dcd login\` to recreate it.`);
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        // Surface the corruption instead of silently behaving as logged-out, so
+        // downstream "Not authenticated" errors aren't mystifying.
+        // eslint-disable-next-line no-console
+        console.warn(`Warning: could not parse config at ${p}; treating as logged out. Run \`dcd login\` to recreate it.`);
+        return null;
+    }
+}
+/**
+ * Resolve the API URL a command should talk to. Precedence:
+ *   1. explicit --api-url flag
+ *   2. api_url stored by `dcd login` (honors the env the user logged into)
+ *   3. prod default
+ *
+ * Without this, session commands default to prod and a dev/staging Bearer
+ * token is rejected with a misleading "Invalid or expired JWT". `switch-org`
+ * has always done this; this helper extends it to every command.
+ */
+export function resolveApiUrl(flag) {
+    const explicit = flag?.trim();
+    if (explicit)
+        return explicit;
+    return readConfig()?.api_url ?? ENVIRONMENTS.prod.apiUrl;
+}
+export function writeConfig(config) {
+    const dir = getConfigDir();
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+    }
+    else {
+        try {
+            chmodSync(dir, 0o700);
+        }
+        catch { /* best effort */ }
+    }
+    const finalPath = getConfigPath();
+    // Best-effort cleanup of orphaned tmp files left behind by crashed writes.
+    // Only remove old ones — a concurrent process may be between its own
+    // writeFileSync and renameSync right now.
+    try {
+        const base = path.basename(finalPath);
+        for (const entry of readdirSync(dir)) {
+            if (!entry.startsWith(`${base}.`) || !entry.endsWith('.tmp'))
+                continue;
+            const tmp = path.join(dir, entry);
+            try {
+                if (Date.now() - statSync(tmp).mtimeMs > 60_000)
+                    unlinkSync(tmp);
+            }
+            catch { /* best effort */ }
+        }
+    }
+    catch { /* best effort */ }
+    const tmpPath = `${finalPath}.${randomBytes(6).toString('hex')}.tmp`;
+    writeFileSync(tmpPath, JSON.stringify(config, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(tmpPath, 0o600);
+    }
+    catch { /* best effort on platforms w/o chmod */ }
+    renameSync(tmpPath, finalPath);
+    try {
+        chmodSync(finalPath, 0o600);
+    }
+    catch { /* best effort */ }
+}
+export function clearConfig() {
+    const p = getConfigPath();
+    if (existsSync(p))
+        unlinkSync(p);
+}
+export function configFileMode() {
+    const p = getConfigPath();
+    if (!existsSync(p))
+        return null;
+    return statSync(p).mode & 0o777;
+}

package/dist/utils/connectivity.js

@@ -1,16 +1,13 @@
-"use strict";
 /**
  * Utility for checking internet connectivity using third-party endpoints
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkInternetConnectivity = checkInternetConnectivity;
 /**
  * Check if the system has internet connectivity by testing against
  * multiple reliable third-party endpoints with detailed diagnostics.
  *
  * @returns Promise<ConnectivityCheckResult> - Detailed connectivity check results
  */
-async function checkInternetConnectivity() {
+export async function checkInternetConnectivity() {
     // Use multiple reliable endpoints to test connectivity
     const testEndpoints = [
         { url: 'https://www.google.com/generate_204', description: 'Google' },
@@ -22,16 +19,15 @@ async function checkInternetConnectivity() {
     // Try each endpoint with a short timeout
     for (const { url, description } of testEndpoints) {
         const startTime = Date.now();
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 second timeout
         try {
-            const controller = new AbortController();
-            const timeoutId = setTimeout(() => controller.abort(), 3000); // 3 second timeout
             const response = await fetch(url, {
                 method: 'HEAD', // Use HEAD to minimize data transfer
                 signal: controller.signal,
                 // Disable redirects to get faster response
                 redirect: 'manual',
             });
-            clearTimeout(timeoutId);
             const latencyMs = Date.now() - startTime;
             // Any response (including 3xx redirects) indicates connectivity
             if (response) {
@@ -81,6 +77,11 @@ async function checkInternetConnectivity() {
             // Continue to next endpoint if this one fails
             continue;
         }
+        finally {
+            // Always clear — a dangling abort timer keeps the event loop alive
+            // for up to 3s per failed endpoint.
+            clearTimeout(timeoutId);
+        }
     }
     // Generate developer-friendly message
     let message;

package/dist/utils/expo.js

@@ -1,17 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isUrl = isUrl;
-exports.downloadExpoUrl = downloadExpoUrl;
-exports.extractTarGz = extractTarGz;
-exports.findAppBundle = findAppBundle;
-const node_crypto_1 = require("node:crypto");
-const fs = require("node:fs");
-const fsp = require("node:fs/promises");
-const os = require("node:os");
-const path = require("node:path");
-const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
-const tar = require("tar");
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import * as tar from 'tar';
 const DOWNLOAD_RETRY_ATTEMPTS = 3;
 const DOWNLOAD_RETRY_DELAY_MS = 2000;
 /**
@@ -19,7 +13,7 @@ const DOWNLOAD_RETRY_DELAY_MS = 2000;
  * @param input - String to test
  * @returns True if the string begins with http:// or https://
  */
-function isUrl(input) {
+export function isUrl(input) {
     return input.startsWith('http://') || input.startsWith('https://');
 }
 /**
@@ -31,8 +25,8 @@ function isUrl(input) {
  * @param debug - Whether to emit debug log lines
  * @returns Absolute path to the downloaded temp file
  */
-async function downloadExpoUrl(url, debug) {
-    const destPath = path.join(os.tmpdir(), `dcd-expo-${(0, node_crypto_1.randomUUID)()}.tar.gz`);
+export async function downloadExpoUrl(url, debug) {
+    const destPath = path.join(os.tmpdir(), `dcd-expo-${randomUUID()}.tar.gz`);
     for (let attempt = 1; attempt <= DOWNLOAD_RETRY_ATTEMPTS; attempt++) {
         if (debug) {
             console.log(`[DEBUG] Downloading Expo URL (attempt ${attempt}/${DOWNLOAD_RETRY_ATTEMPTS}): ${url}`);
@@ -40,17 +34,27 @@ async function downloadExpoUrl(url, debug) {
         try {
             const response = await fetch(url);
             if (!response.ok) {
+                // 4xx responses (expired signed URL, 404, ...) won't get better on
+                // retry — flag them so the catch below rethrows immediately.
+                const permanent = response.status >= 400 && response.status < 500;
+                let error;
                 if (response.status === 403 || response.status === 401) {
-                    throw new Error(`Failed to download Expo build from URL (HTTP ${response.status}). Expo signed URLs expire after ~1 hour — please generate a fresh URL with 'eas build' and try again.`);
+                    error = new Error(`Failed to download Expo build from URL (HTTP ${response.status}). Expo signed URLs expire after ~1 hour — please generate a fresh URL with 'eas build' and try again.`);
                 }
-                throw new Error(`Failed to download Expo build from URL (HTTP ${response.status}).`);
+                else {
+                    error = new Error(`Failed to download Expo build from URL (HTTP ${response.status}).`);
+                }
+                if (permanent) {
+                    error.permanent = true;
+                }
+                throw error;
             }
             if (!response.body) {
                 throw new Error('No response body received from Expo URL.');
             }
             // Stream to disk using pipeline to handle backpressure and avoid loading
             // the entire archive in memory
-            await (0, promises_1.pipeline)(node_stream_1.Readable.fromWeb(response.body), fs.createWriteStream(destPath));
+            await pipeline(Readable.fromWeb(response.body), fs.createWriteStream(destPath));
             if (debug) {
                 const stat = await fsp.stat(destPath);
                 console.log(`[DEBUG] Downloaded ${(stat.size / 1024 / 1024).toFixed(2)} MB to ${destPath}`);
@@ -60,8 +64,9 @@ async function downloadExpoUrl(url, debug) {
         catch (error) {
             // Clean up any partial file before retrying
             await fsp.rm(destPath, { force: true }).catch(() => { });
+            const isPermanent = Boolean(error?.permanent);
             const isLastAttempt = attempt === DOWNLOAD_RETRY_ATTEMPTS;
-            if (isLastAttempt) {
+            if (isPermanent || isLastAttempt) {
                 throw error;
             }
             if (debug) {
@@ -80,8 +85,8 @@ async function downloadExpoUrl(url, debug) {
  * @param debug - Whether to emit debug log lines
  * @returns Absolute path to the newly created extract directory
  */
-async function extractTarGz(tarPath, debug) {
-    const extractDir = path.join(os.tmpdir(), `dcd-expo-${(0, node_crypto_1.randomUUID)()}`);
+export async function extractTarGz(tarPath, debug) {
+    const extractDir = path.join(os.tmpdir(), `dcd-expo-${randomUUID()}`);
     await fsp.mkdir(extractDir, { recursive: true });
     if (debug) {
         console.log(`[DEBUG] Extracting ${tarPath} to ${extractDir}`);
@@ -98,7 +103,7 @@ async function extractTarGz(tarPath, debug) {
  * @param dir - Directory to search within
  * @returns Absolute path to the .app directory
  */
-async function findAppBundle(dir) {
+export async function findAppBundle(dir) {
     const candidates = [];
     async function walk(current, depth) {
         const entries = await fsp.readdir(current, { withFileTypes: true });

package/dist/utils/orgs.d.ts

@@ -0,0 +1,11 @@
+export interface OrgListItem {
+    id: string;
+    name: string;
+    slug?: string;
+}
+export declare function fetchOrgs(apiUrl: string, headers: Record<string, string>): Promise<OrgListItem[]>;
+/**
+ * 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>;

package/dist/utils/orgs.js

@@ -0,0 +1,36 @@
+/**
+ * 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`.
+ */
+import * as p from '@clack/prompts';
+import { CliError } from './cli.js';
+export async function fetchOrgs(apiUrl, headers) {
+    const res = await fetch(`${apiUrl.replace(/\/$/, '')}/me/orgs`, { headers });
+    if (!res.ok) {
+        const body = await res.text().catch(() => '');
+        throw new CliError(`Failed to list organizations: HTTP ${res.status}${body ? ` — ${body}` : ''}`);
+    }
+    const body = (await res.json());
+    return body.orgs ?? [];
+}
+/**
+ * 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') {
+    if (orgs.length === 0) {
+        throw new CliError('No organizations found for this user.');
+    }
+    if (orgs.length === 1)
+        return orgs[0];
+    const picked = await p.select({
+        message,
+        options: orgs.map((o) => ({ value: o.id, label: o.name })),
+    });
+    if (p.isCancel(picked))
+        throw new CliError('Cancelled.');
+    const chosen = orgs.find((o) => o.id === picked);
+    if (!chosen)
+        throw new CliError('No organization selected.');
+    return chosen;
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert an absolute path into the portable './'-prefixed, forward-slash
+ * relative form used as flow keys across submission, metadata maps, and
+ * polling. `commonRoot` must be a whole-segment prefix of `absolutePath`
+ * without a trailing separator (or '' when no common root exists, in which
+ * case the path is kept whole apart from separator normalization).
+ *
+ * Replaces the old `replaceAll(commonRoot, '.')` pattern, which corrupted
+ * paths when the root substring recurred mid-path or collapsed to ''.
+ */
+export declare function toPortableRelativePath(absolutePath: string, commonRoot: string): string;

package/dist/utils/paths.js

@@ -0,0 +1,21 @@
+import * as path from 'node:path';
+/**
+ * Convert an absolute path into the portable './'-prefixed, forward-slash
+ * relative form used as flow keys across submission, metadata maps, and
+ * polling. `commonRoot` must be a whole-segment prefix of `absolutePath`
+ * without a trailing separator (or '' when no common root exists, in which
+ * case the path is kept whole apart from separator normalization).
+ *
+ * Replaces the old `replaceAll(commonRoot, '.')` pattern, which corrupted
+ * paths when the root substring recurred mid-path or collapsed to ''.
+ */
+export function toPortableRelativePath(absolutePath, commonRoot) {
+    let relative = absolutePath;
+    if (commonRoot && absolutePath.startsWith(commonRoot)) {
+        relative = absolutePath.slice(commonRoot.length);
+    }
+    if (!relative.startsWith(path.sep)) {
+        relative = path.sep + relative;
+    }
+    return ('.' + relative).split(path.sep).join('/');
+}

package/dist/utils/progress.d.ts

@@ -0,0 +1,13 @@
+declare class Action {
+    private current;
+    private _status;
+    start(title: string, initialStatus?: string, _opts?: unknown): void;
+    stop(message?: string): void;
+    set status(value: string);
+    get status(): string;
+}
+export declare const ux: {
+    action: Action;
+    info(message: string): void;
+};
+export {};

package/dist/utils/progress.js

@@ -0,0 +1,47 @@
+/**
+ * Progress adapter that wraps @clack/prompts spinner with a
+ * drop-in API for existing services that used oclif's `ux.action` / `ux.info`.
+ *
+ * Keeps call sites unchanged while migrating away from @oclif/core.
+ */
+import * as p from '@clack/prompts';
+class Action {
+    current = null;
+    _status = '';
+    start(title, initialStatus, _opts) {
+        if (this.current) {
+            this.current.stop();
+        }
+        this.current = p.spinner();
+        this._status = initialStatus ?? '';
+        this.current.start(initialStatus ? `${title} — ${initialStatus}` : title);
+    }
+    stop(message) {
+        if (!this.current) {
+            if (message) {
+                // eslint-disable-next-line no-console
+                console.log(message);
+            }
+            return;
+        }
+        this.current.stop(message ?? '');
+        this.current = null;
+        this._status = '';
+    }
+    set status(value) {
+        this._status = value;
+        if (this.current && value) {
+            this.current.message(value);
+        }
+    }
+    get status() {
+        return this._status;
+    }
+}
+export const ux = {
+    action: new Action(),
+    info(message) {
+        // eslint-disable-next-line no-console
+        console.log(message);
+    },
+};

package/dist/utils/styling.d.ts

@@ -1,8 +1,9 @@
-import chalk = require('chalk');
 /**
  * Centralized styling utilities for CLI output
  * Provides consistent, developer-friendly visual formatting
  */
+/** Strip ANSI color escape sequences for visible-width calculations. */
+export declare const stripAnsi: (s: string) => string;
 /**
  * Status symbols with associated colors
  */
@@ -21,50 +22,49 @@ export declare const symbols: {
  * Color utility functions for semantic styling
  */
 export declare const colors: {
-    readonly bold: chalk.Chalk;
-    readonly dim: chalk.Chalk;
-    readonly error: chalk.Chalk;
-    readonly highlight: chalk.Chalk;
-    readonly info: chalk.Chalk;
-    readonly success: chalk.Chalk;
-    readonly url: chalk.Chalk;
-    readonly warning: chalk.Chalk;
+    readonly bold: import("chalk").ChalkInstance;
+    readonly dim: import("chalk").ChalkInstance;
+    readonly error: import("chalk").ChalkInstance;
+    readonly highlight: import("chalk").ChalkInstance;
+    readonly info: import("chalk").ChalkInstance;
+    readonly success: import("chalk").ChalkInstance;
+    readonly url: import("chalk").ChalkInstance;
+    readonly warning: import("chalk").ChalkInstance;
 };
 /**
- * Dividers for visual separation
+ * Structural glyphs that give the CLI its tree-shaped layout. `section` marks a
+ * top-level heading; `branch` opens the group of detail rows beneath it.
+ * See STYLE_GUIDE.md.
  */
-export declare const dividers: {
-    readonly heavy: string;
-    readonly light: string;
-    readonly short: string;
+export declare const glyphs: {
+    readonly branch: "⎿";
+    readonly section: "⏺";
 };
 /**
- * Format a status with appropriate symbol and color
+ * The single source of truth mapping a run/test status to its colour and
+ * (already-coloured) symbol. Both {@link formatStatus} and the `ui` status
+ * helpers build on this, so every status reads identically everywhere.
+ * @param status - The status string (case-insensitive)
+ */
+export declare function statusPalette(status: string): {
+    color: (s: string) => string;
+    symbol: string;
+};
+/**
+ * Format a status as a coloured symbol followed by the lowercased status word,
+ * e.g. `✓ passed`.
  * @param status - The status string to format
  * @returns Formatted status string with color and symbol
  */
 export declare function formatStatus(status: string): string;
 /**
- * Format a section header
+ * Format a top-level section header in the tree style: a `⏺` marker followed by
+ * the bold title, preceded by a blank line for separation. Detail rows belong
+ * underneath in a branch group (see the `ui` helpers).
  * @param title - The title of the section
  * @returns Formatted section header
  */
 export declare function sectionHeader(title: string): string;
-/**
- * Format a key-value pair with optional icon
- * @param icon - Icon to display before the key
- * @param key - The key name
- * @param value - The value to display
- * @returns Formatted key-value string
- */
-export declare function keyValue(icon: string, key: string, value: string): string;
-/**
- * Format a list item
- * @param text - The text of the list item
- * @param prefix - The prefix character (default: '•')
- * @returns Formatted list item
- */
-export declare function listItem(text: string, prefix?: string): string;
 /**
  * Format a URL
  * @param url - The URL to format
@@ -92,14 +92,20 @@ export declare function formatTestSummary(summary: {
     total: number;
 }): string;
 /**
- * Format a box with content
- * @param content - The content to display in the box
- * @returns Formatted box with borders
+ * Minimal column table renderer.
+ * Columns are defined with a `get(row) => string` accessor and optional header label.
+ * Matches the subset of oclif's ux.table used by this CLI.
  */
-export declare function box(content: string): string;
+export declare function table<T>(rows: T[], columns: Record<string, {
+    get: (row: T) => string;
+    header?: string;
+}>, options?: {
+    printLine?: (line: string) => void;
+}): void;
 /**
  * Generate console URL based on API URL
- * If a non-default API URL is used, prepends "dev." to the console subdomain
+ * Derives the console host from the known environment matching the API URL;
+ * unknown API URLs fall back to the dev console (historical behavior).
  * @param apiUrl - The API URL being used
  * @param uploadId - The upload ID
  * @param resultId - The result ID