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

package/dist/commands/status.js

@@ -1,204 +1,195 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const constants_1 = require("../constants");
-const api_gateway_1 = require("../gateways/api-gateway");
-const methods_1 = require("../methods");
-const connectivity_1 = require("../utils/connectivity");
-const styling_1 = require("../utils/styling");
-class Status extends core_1.Command {
-    static description = 'Get the status of an upload by name or upload ID';
-    static enableJsonFlag = true;
-    static examples = [
-        '<%= config.bin %> <%= command.id %> --name my-upload-name',
-        '<%= config.bin %> <%= command.id %> --upload-id 123e4567-e89b-12d3-a456-426614174000 --json',
-    ];
-    static flags = {
-        apiKey: constants_1.flags.apiKey,
-        apiUrl: constants_1.flags.apiUrl,
-        json: core_1.Flags.boolean({
+import { defineCommand } from 'citty';
+import { apiFlags } from '../config/flags/api.flags.js';
+import { ApiGateway } from '../gateways/api-gateway.js';
+import { formatDurationSeconds } from '../methods.js';
+import { resolveAuth } from '../utils/auth.js';
+import { CliError, logger } from '../utils/cli.js';
+import { resolveApiUrl } from '../utils/config-store.js';
+import { checkInternetConnectivity, } from '../utils/connectivity.js';
+import { colors, formatId, formatUrl } from '../utils/styling.js';
+import { ui } from '../utils/ui.js';
+/** Errors the API gateway surfaces for 4xx-class failures — retrying is pointless. */
+function isClientApiError(error) {
+    if (!error)
+        return false;
+    return (error.message.includes('Invalid request:') ||
+        error.message.includes('Resource not found') ||
+        error.message.includes('Authentication failed') ||
+        error.message.includes('Access denied') ||
+        error.message.includes('Invalid API key') ||
+        error.message.includes('Rate limit exceeded'));
+}
+function formatDateTime(isoString) {
+    try {
+        const date = new Date(isoString);
+        return date.toLocaleString();
+    }
+    catch {
+        return isoString;
+    }
+}
+export const statusCommand = defineCommand({
+    meta: {
+        name: 'status',
+        description: 'Get the status of an upload by name or upload ID',
+    },
+    args: {
+        ...apiFlags,
+        json: {
+            type: 'boolean',
             description: 'output in json format',
-        }),
-        name: core_1.Flags.string({
+        },
+        name: {
+            type: 'string',
             description: 'Name of the upload to check status for',
-            exclusive: ['upload-id'],
-        }),
-        'upload-id': core_1.Flags.string({
+        },
+        'upload-id': {
+            type: 'string',
             description: 'UUID of the upload to check status for',
-            exclusive: ['name'],
-        }),
-    };
+        },
+    },
     // eslint-disable-next-line complexity
-    async run() {
-        const { flags } = await this.parse(Status);
-        const { apiKey: apiKeyFlag, apiUrl, json, name, 'upload-id': uploadId, } = flags;
-        const apiKey = apiKeyFlag || process.env.DEVICE_CLOUD_API_KEY;
-        if (!apiKey) {
-            this.error('API key is required. Please provide it via --api-key flag or DEVICE_CLOUD_API_KEY environment variable.');
-            return;
+    async run({ args }) {
+        const apiKeyFlag = args['api-key'];
+        const apiUrl = resolveApiUrl(args['api-url']);
+        const json = Boolean(args.json);
+        const name = args.name;
+        const uploadId = args['upload-id'];
+        try {
+            await statusMain({ apiKeyFlag, apiUrl, json, name, uploadId });
         }
-        if (name && uploadId) {
-            this.error('Cannot provide both --name and --upload-id. These options are mutually exclusive.');
-            return;
+        catch (error) {
+            logger.error(error, { exit: 1, json });
         }
-        if (!name && !uploadId) {
-            this.error('Either --name or --upload-id must be provided');
-            return;
+    },
+});
+async function statusMain({ apiKeyFlag, apiUrl, json, name, uploadId, }) {
+    const auth = await resolveAuth({ apiKeyFlag });
+    if (name && uploadId) {
+        throw new CliError('Cannot provide both --name and --upload-id. These options are mutually exclusive.');
+    }
+    if (!name && !uploadId) {
+        throw new CliError('Either --name or --upload-id must be provided');
+    }
+    let lastError = null;
+    let status = null;
+    let attemptsMade = 0;
+    for (let attempt = 1; attempt <= 5; attempt++) {
+        try {
+            attemptsMade = attempt;
+            status = (await ApiGateway.getUploadStatus(apiUrl, auth, {
+                name,
+                uploadId,
+            }));
+            break;
         }
-        let lastError = null;
-        let status = null;
-        let attemptsMade = 0;
-        for (let attempt = 1; attempt <= 5; attempt++) {
-            try {
-                attemptsMade = attempt;
-                status = (await api_gateway_1.ApiGateway.getUploadStatus(apiUrl, apiKey, {
-                    name,
-                    uploadId,
-                }));
+        catch (error) {
+            lastError = error;
+            const isNetworkError = lastError.name === 'NetworkError' ||
+                (error instanceof TypeError && lastError.message === 'fetch failed');
+            if (isClientApiError(lastError)) {
                 break;
             }
-            catch (error) {
-                lastError = error;
-                // Check if this is a retryable error (network/timeout issues)
-                // Non-retryable errors: 4xx client errors (bad request, not found, unauthorized, forbidden)
-                const isNetworkError = lastError.name === 'NetworkError' ||
-                    (error instanceof TypeError && lastError.message === 'fetch failed');
-                const isClientError = lastError.message.includes('Invalid request:') ||
-                    lastError.message.includes('Resource not found') ||
-                    lastError.message.includes('Authentication failed') ||
-                    lastError.message.includes('Access denied') ||
-                    lastError.message.includes('Invalid API key') ||
-                    lastError.message.includes('Rate limit exceeded');
-                // Don't retry client errors - they won't succeed on retry
-                if (isClientError) {
-                    break;
-                }
-                // Only retry network errors
-                if (attempt < 5 && isNetworkError) {
-                    this.log(`Network error on attempt ${attempt}/5. Retrying...`);
-                    await new Promise((resolve) => {
-                        setTimeout(resolve, 1000 * attempt);
-                    });
-                }
-                else if (attempt < 5) {
-                    // For other errors (server errors), retry but with different message
-                    this.log(`Request failed on attempt ${attempt}/5. Retrying...`);
-                    await new Promise((resolve) => {
-                        setTimeout(resolve, 1000 * attempt);
-                    });
-                }
+            if (attempt < 5) {
+                logger.log(isNetworkError
+                    ? `Network error on attempt ${attempt}/5. Retrying...`
+                    : `Request failed on attempt ${attempt}/5. Retrying...`);
+                await new Promise((resolve) => {
+                    setTimeout(resolve, 1000 * attempt);
+                });
             }
         }
-        if (!status) {
-            // Check if this was a client error (non-retryable)
-            const isClientError = lastError && (lastError.message.includes('Invalid request:') ||
-                lastError.message.includes('Resource not found') ||
-                lastError.message.includes('Authentication failed') ||
-                lastError.message.includes('Access denied') ||
-                lastError.message.includes('Invalid API key') ||
-                lastError.message.includes('Rate limit exceeded'));
-            if (isClientError) {
-                // For client errors, show the error immediately without connectivity check
-                const errorMessage = lastError?.message || 'Unknown error';
-                if (json) {
-                    return {
-                        status: 'FAILED',
-                        error: errorMessage,
-                        attempts: attemptsMade,
-                        tests: [],
-                    };
-                }
-                this.error(errorMessage);
-            }
-            // Check if the failure is due to internet connectivity issues
-            const connectivityCheck = await (0, connectivity_1.checkInternetConnectivity)();
-            let errorMessage;
-            if (connectivityCheck.connected) {
-                errorMessage = `Failed to get status after ${attemptsMade} attempt${attemptsMade > 1 ? 's' : ''}. Internet appears functional but unable to reach API. Last error: ${lastError?.message || 'Unknown error'}`;
-            }
-            else {
-                // Build detailed error message with endpoint diagnostics
-                const endpointDetails = connectivityCheck.endpointResults
-                    .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
-                    .join('\n');
-                errorMessage = `Failed to get status after ${attemptsMade} attempt${attemptsMade > 1 ? 's' : ''}.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.\nLast API error: ${lastError?.message || 'Unknown error'}`;
-            }
+    }
+    if (!status) {
+        if (isClientApiError(lastError)) {
+            const errorMessage = lastError?.message || 'Unknown error';
             if (json) {
-                return {
+                // eslint-disable-next-line no-console
+                console.log(JSON.stringify({
                     status: 'FAILED',
                     error: errorMessage,
                     attempts: attemptsMade,
-                    connectivityCheck: {
-                        connected: connectivityCheck.connected,
-                        endpointResults: connectivityCheck.endpointResults,
-                        message: connectivityCheck.message,
-                    },
                     tests: [],
-                };
+                }, null, 2));
+                return;
             }
-            this.error(errorMessage);
+            throw new CliError(errorMessage);
         }
-        try {
-            if (json) {
-                // Reconstruct object to ensure tests appears at the bottom
-                const { tests, ...rest } = status;
-                return {
-                    ...rest,
-                    tests,
-                };
-            }
-            this.log((0, styling_1.sectionHeader)('Upload Status'));
-            // Display overall status
-            this.log(`   ${(0, styling_1.formatStatus)(status.status)}`);
-            if (status.name) {
-                this.log(`   ${styling_1.colors.dim('Name:')} ${styling_1.colors.bold(status.name)}`);
-            }
-            if (status.uploadId) {
-                this.log(`   ${styling_1.colors.dim('Upload ID:')} ${(0, styling_1.formatId)(status.uploadId)}`);
-            }
-            if (status.appBinaryId) {
-                this.log(`   ${styling_1.colors.dim('Binary ID:')} ${(0, styling_1.formatId)(status.appBinaryId)}`);
-            }
-            if (status.createdAt) {
-                this.log(`   ${styling_1.colors.dim('Created:')} ${this.formatDateTime(status.createdAt)}`);
-            }
-            if (status.consoleUrl) {
-                this.log(`   ${styling_1.colors.dim('Console:')} ${(0, styling_1.formatUrl)(status.consoleUrl)}`);
-            }
-            if (status.tests.length > 0) {
-                this.log((0, styling_1.sectionHeader)('Test Results'));
-                for (const item of status.tests) {
-                    this.log(`   ${(0, styling_1.formatStatus)(item.status)} ${styling_1.colors.bold(item.name)}`);
-                    if (item.status === 'FAILED' && item.failReason) {
-                        this.log(`      ${styling_1.colors.error('Fail reason:')} ${item.failReason}`);
-                    }
-                    if (item.durationSeconds) {
-                        this.log(`      ${styling_1.colors.dim('Duration:')} ${(0, methods_1.formatDurationSeconds)(item.durationSeconds)}`);
-                    }
-                    if (item.createdAt) {
-                        this.log(`      ${styling_1.colors.dim('Created:')} ${this.formatDateTime(item.createdAt)}`);
-                    }
-                    this.log('');
-                }
-            }
+        const connectivityCheck = await checkInternetConnectivity();
+        let errorMessage;
+        if (connectivityCheck.connected) {
+            errorMessage = `Failed to get status after ${attemptsMade} attempt${attemptsMade > 1 ? 's' : ''}. Internet appears functional but unable to reach API. Last error: ${lastError?.message || 'Unknown error'}`;
         }
-        catch (error) {
-            this.error(`Failed to get status: ${error.message}`);
+        else {
+            const endpointDetails = connectivityCheck.endpointResults
+                .map((r) => `  - ${r.endpoint}: ${r.error} (${r.latencyMs}ms)`)
+                .join('\n');
+            errorMessage = `Failed to get status after ${attemptsMade} attempt${attemptsMade > 1 ? 's' : ''}.\n\nInternet connectivity check failed - all test endpoints unreachable:\n${endpointDetails}\n\nPlease verify your network connection and DNS resolution.\nLast API error: ${lastError?.message || 'Unknown error'}`;
+        }
+        if (json) {
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({
+                status: 'FAILED',
+                error: errorMessage,
+                attempts: attemptsMade,
+                connectivityCheck: {
+                    connected: connectivityCheck.connected,
+                    endpointResults: connectivityCheck.endpointResults,
+                    message: connectivityCheck.message,
+                },
+                tests: [],
+            }, null, 2));
+            return;
         }
+        throw new CliError(errorMessage);
     }
-    /**
-     * Format an ISO date string to a human-readable local date/time
-     * @param isoString - ISO 8601 date string
-     * @returns Formatted local date/time string
-     */
-    formatDateTime(isoString) {
-        try {
-            const date = new Date(isoString);
-            return date.toLocaleString();
+    try {
+        if (json) {
+            const { tests, ...rest } = status;
+            // eslint-disable-next-line no-console
+            console.log(JSON.stringify({ ...rest, tests }, null, 2));
+            return;
+        }
+        const fields = [];
+        if (status.name) {
+            fields.push(['name', colors.bold(status.name)]);
+        }
+        if (status.uploadId) {
+            fields.push(['upload id', formatId(status.uploadId)]);
+        }
+        if (status.appBinaryId) {
+            fields.push(['binary id', formatId(status.appBinaryId)]);
+        }
+        if (status.createdAt) {
+            fields.push(['created', formatDateTime(status.createdAt)]);
         }
-        catch {
-            return isoString;
+        if (status.consoleUrl) {
+            fields.push(['console', formatUrl(status.consoleUrl)]);
         }
+        logger.log(ui.section('Upload Status'));
+        logger.log(ui.branch([ui.status(status.status), ...ui.fields(fields)]));
+        if (status.tests.length > 0) {
+            logger.log(ui.section('Test Results'));
+            logger.log(ui.branch(status.tests.map((item) => {
+                const head = `${ui.statusSymbol(item.status)} ${item.name}`;
+                const meta = [];
+                if (item.durationSeconds) {
+                    meta.push(formatDurationSeconds(item.durationSeconds));
+                }
+                if (item.createdAt) {
+                    meta.push(colors.dim(formatDateTime(item.createdAt)));
+                }
+                if (item.status === 'FAILED' && item.failReason) {
+                    meta.push(colors.error(item.failReason));
+                }
+                return meta.length > 0
+                    ? `${head}   ${colors.dim('·')} ${meta.join(colors.dim(' · '))}`
+                    : head;
+            })));
+        }
+    }
+    catch (error) {
+        throw new CliError(`Failed to get status: ${error.message}`);
     }
 }
-exports.default = Status;
+export default statusCommand;

package/dist/commands/switch-org.d.ts

@@ -0,0 +1,12 @@
+export declare const switchOrgCommand: import("citty").CommandDef<{
+    readonly 'api-url': {
+        readonly type: "string";
+        readonly description: "API base URL (defaults to the URL stored by `dcd login`)";
+    };
+    readonly org: {
+        readonly type: "positional";
+        readonly required: false;
+        readonly description: "Org name to switch to (omit for an interactive picker)";
+    };
+}>;
+export default switchOrgCommand;

package/dist/commands/switch-org.js

@@ -0,0 +1,76 @@
+/**
+ * `dcd switch-org` — changes the active org on the stored session.
+ *
+ * With an argument (`dcd switch-org <name>`): update config immediately after
+ * confirming the user is a member via GET /me/orgs.
+ * Without an argument: fetch orgs and prompt the user to pick one.
+ */
+import { defineCommand } from 'citty';
+import { resolveAuth } from '../utils/auth.js';
+import { CliError, logger } from '../utils/cli.js';
+import { readConfig, resolveApiUrl, writeConfig } from '../utils/config-store.js';
+import { fetchOrgs, pickOrg } from '../utils/orgs.js';
+import { colors } from '../utils/styling.js';
+import { ui } from '../utils/ui.js';
+export const switchOrgCommand = defineCommand({
+    meta: {
+        name: 'switch-org',
+        description: 'Switch the active organization for the logged-in session',
+    },
+    args: {
+        'api-url': {
+            type: 'string',
+            description: 'API base URL (defaults to the URL stored by `dcd login`)',
+        },
+        org: {
+            type: 'positional',
+            required: false,
+            description: 'Org name to switch to (omit for an interactive picker)',
+        },
+    },
+    async run({ args }) {
+        const config = readConfig();
+        if (!config?.session) {
+            throw new CliError('Not logged in. Run `dcd login` first.');
+        }
+        // Honor the env the user logged into — defaulting to prod here would send
+        // a dev Bearer token to the prod API.
+        const apiUrl = resolveApiUrl(args['api-url']);
+        const target = args.org;
+        // sessionOnly: an exported DEVICE_CLOUD_API_KEY must not shadow the
+        // browser session this command requires.
+        const auth = await resolveAuth({ apiKeyFlag: undefined, sessionOnly: true });
+        const orgs = await fetchOrgs(apiUrl, auth.headers);
+        let chosen;
+        if (target) {
+            chosen = matchOrg(orgs, target);
+        }
+        else {
+            chosen = await pickOrg(orgs);
+        }
+        writeConfig({
+            ...config,
+            current_org_id: chosen.id,
+            current_org_name: chosen.name,
+        });
+        logger.log(ui.success(`Switched to ${colors.highlight(chosen.name)}`));
+    },
+});
+/**
+ * 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.
+ */
+function matchOrg(orgs, target) {
+    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 \`dcd switch-org\` without arguments 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;
+}
+export default switchOrgCommand;

package/dist/commands/upgrade.d.ts

@@ -0,0 +1,2 @@
+export declare const upgradeCommand: import("citty").CommandDef<import("citty").ArgsDef>;
+export default upgradeCommand;

package/dist/commands/upgrade.js

@@ -0,0 +1,120 @@
+/**
+ * `dcd upgrade` — in-place replace of the standalone binary.
+ *
+ * Only meaningful for the bun-compiled binary install. npm-installed users
+ * are redirected to `npm install -g`. Fetches the latest version from the
+ * release manifest, downloads the matching binary, verifies its SHA256
+ * against the published SHA256SUMS, then atomically renames over the running
+ * executable (the old inode stays alive until the process exits).
+ */
+import { createHash } from 'node:crypto';
+import { chmodSync, createReadStream, createWriteStream, renameSync, unlinkSync, } from 'node:fs';
+import { Readable } from 'node:stream';
+import { pipeline } from 'node:stream/promises';
+import { defineCommand } from 'citty';
+import { VersionService } from '../services/version.service.js';
+import { CliError, getCliVersion, getInstallMethod, logger, } from '../utils/cli.js';
+import { colors } from '../utils/styling.js';
+import { ui } from '../utils/ui.js';
+const DEFAULT_DOWNLOAD_BASE = 'https://get.devicecloud.dev';
+// Maps `${process.platform}-${process.arch}` to the GitHub Release asset filename
+// produced by scripts/build-binaries.mjs. Keys must stay in sync with that script.
+const ASSET_BY_PLATFORM = {
+    'darwin-arm64': 'dcd-darwin-arm64',
+    'darwin-x64': 'dcd-darwin-x64',
+    'linux-arm64': 'dcd-linux-arm64',
+    'linux-x64': 'dcd-linux-x64',
+    'win32-x64': 'dcd-windows-x64.exe',
+};
+export const upgradeCommand = defineCommand({
+    meta: {
+        name: 'upgrade',
+        description: 'Upgrade dcd in place to the latest released version',
+    },
+    async run() {
+        if (getInstallMethod() !== 'binary') {
+            throw new CliError('`dcd upgrade` only applies to the standalone binary install. ' +
+                'Run: npm install -g @devicecloud.dev/dcd@latest');
+        }
+        const current = getCliVersion();
+        const versionService = new VersionService();
+        const latest = await versionService.checkLatestCliVersion();
+        if (!latest) {
+            throw new CliError('Could not reach the update manifest. Check your network connection and try again.');
+        }
+        if (!versionService.isOutdated(current, latest)) {
+            logger.log(ui.success(`Already on the latest version (${colors.highlight(current)})`));
+            return;
+        }
+        const platformKey = `${process.platform}-${process.arch}`;
+        const asset = ASSET_BY_PLATFORM[platformKey];
+        if (!asset) {
+            throw new CliError(`No binary published for ${platformKey}. Supported platforms: ${Object.keys(ASSET_BY_PLATFORM).join(', ')}`);
+        }
+        if (process.platform === 'win32') {
+            // Windows can't replace a running .exe; defer to a re-run of the installer.
+            const base = process.env.DCD_DOWNLOAD_BASE ?? DEFAULT_DOWNLOAD_BASE;
+            throw new CliError(`Automatic upgrade on Windows is not yet supported. Re-run the installer:\n  irm ${base}/install.ps1 | iex`);
+        }
+        const base = process.env.DCD_DOWNLOAD_BASE ?? DEFAULT_DOWNLOAD_BASE;
+        const binaryUrl = `${base}/download/${latest}/${asset}`;
+        const sumsUrl = `${base}/download/${latest}/SHA256SUMS`;
+        logger.log(ui.info(`Upgrading ${colors.highlight(current)} → ${colors.highlight(latest)}`));
+        logger.log(ui.note(`  ${binaryUrl}`));
+        const execPath = process.execPath;
+        const tmpPath = `${execPath}.new`;
+        try {
+            await downloadToFile(binaryUrl, tmpPath);
+            const expected = await fetchExpectedChecksum(sumsUrl, asset);
+            const actual = await sha256File(tmpPath);
+            if (expected !== actual) {
+                throw new Error(`Checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
+            }
+            chmodSync(tmpPath, 0o755);
+            // rename is atomic on the same filesystem; on POSIX the running process
+            // keeps the old inode open until exit, so this is safe to do mid-run.
+            renameSync(tmpPath, execPath);
+        }
+        catch (e) {
+            safeUnlink(tmpPath);
+            throw new CliError(`Upgrade failed: ${e.message}. The existing binary at ${execPath} was not modified.`);
+        }
+        logger.log(ui.success(`Upgraded to ${colors.highlight(latest)}`));
+    },
+});
+async function downloadToFile(url, dest) {
+    const res = await fetch(url, { redirect: 'follow' });
+    if (!res.ok || !res.body) {
+        throw new Error(`HTTP ${res.status} fetching ${url}`);
+    }
+    // Node 22 exposes Readable.fromWeb for piping a WHATWG ReadableStream.
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(dest));
+}
+async function fetchExpectedChecksum(sumsUrl, asset) {
+    const res = await fetch(sumsUrl, { redirect: 'follow' });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status} fetching ${sumsUrl}`);
+    const body = await res.text();
+    for (const line of body.split('\n')) {
+        const match = line.match(/^([a-f0-9]{64})\s+(.+)$/);
+        if (match && match[2].trim() === asset)
+            return match[1];
+    }
+    throw new Error(`SHA256SUMS has no entry for ${asset}`);
+}
+async function sha256File(path) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path)) {
+        hash.update(chunk);
+    }
+    return hash.digest('hex');
+}
+function safeUnlink(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch {
+        // Best-effort cleanup; failure here would only leave a .new file.
+    }
+}
+export default upgradeCommand;

package/dist/commands/upload.d.ts

@@ -1,20 +1,35 @@
-import { Command } from '@oclif/core';
-export default class Upload extends Command {
-    static args: {
-        appFile: import("@oclif/core/lib/interfaces").Arg<string, Record<string, unknown>>;
+export declare const uploadCommand: import("citty").CommandDef<{
+    readonly 'app-url': {
+        readonly type: "string";
+        readonly description: "Signed URL to an Expo iOS build (.tar.gz). The archive is downloaded and extracted automatically. Expo signed URLs expire after ~1 hour.";
     };
-    static description: string;
-    static enableJsonFlag: boolean;
-    static examples: string[];
-    static flags: {
-        apiKey: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        apiUrl: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        'app-url': import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
-        debug: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        'ignore-sha-check': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    readonly 'ignore-sha-check': {
+        readonly type: "boolean";
+        readonly description: "Ignore the sha hash check and upload the binary regardless of whether it already exists (not recommended)";
     };
-    run(): Promise<{
-        appBinaryId: string;
-    }>;
-    protected toErrorJson(err: unknown): unknown;
-}
+    readonly debug: {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly description: "Enable detailed debug logging for troubleshooting issues";
+    };
+    readonly json: {
+        readonly type: "boolean";
+        readonly description: "Output results in JSON format. Exit codes: 0 on success, 2 if the test run fails, 1 on CLI/infrastructure errors";
+    };
+    readonly appFile: {
+        readonly type: "positional";
+        readonly required: false;
+        readonly description: "The binary file or Expo signed URL to upload (e.g. test.apk, test.app, test.zip, build.tar.gz, or https://expo.dev/...)";
+    };
+    readonly 'api-key': {
+        readonly type: "string";
+        readonly alias: ["apiKey"];
+        readonly description: "API key for devicecloud.dev (find this in the console UI). You can also set the DEVICE_CLOUD_API_KEY environment variable.";
+    };
+    readonly 'api-url': {
+        readonly type: "string";
+        readonly alias: ["apiURL", "apiUrl"];
+        readonly description: "API base URL (defaults to the URL stored by `dcd login`, else prod)";
+    };
+}>;
+export default uploadCommand;