@devicecloud.dev/dcd 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/commands/upgrade.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.upgradeCommand = void 0;
 /**
  * `dcd upgrade` — in-place replace of the standalone binary.
  *
@@ -10,14 +7,15 @@ exports.upgradeCommand = void 0;
  * against the published SHA256SUMS, then atomically renames over the running
  * executable (the old inode stays alive until the process exits).
  */
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const node_stream_1 = require("node:stream");
-const promises_1 = require("node:stream/promises");
-const citty_1 = require("citty");
-const version_service_1 = require("../services/version.service");
-const cli_1 = require("../utils/cli");
-const styling_1 = require("../utils/styling");
+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.
@@ -28,41 +26,51 @@ const ASSET_BY_PLATFORM = {
     'linux-x64': 'dcd-linux-x64',
     'win32-x64': 'dcd-windows-x64.exe',
 };
-exports.upgradeCommand = (0, citty_1.defineCommand)({
+export const upgradeCommand = defineCommand({
     meta: {
         name: 'upgrade',
         description: 'Upgrade dcd in place to the latest released version',
     },
     async run() {
-        if ((0, cli_1.getInstallMethod)() !== 'binary') {
-            throw new cli_1.CliError('`dcd upgrade` only applies to the standalone binary install. ' +
+        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 = (0, cli_1.getCliVersion)();
-        const versionService = new version_service_1.VersionService();
-        const latest = await versionService.checkLatestCliVersion();
-        if (!latest) {
-            throw new cli_1.CliError('Could not reach the update manifest. Check your network connection and try again.');
+        const current = getCliVersion();
+        const versionService = new VersionService();
+        const result = await versionService.checkLatestCliVersion(current);
+        if (!result.ok) {
+            throw new CliError(`Could not reach the update manifest (${result.error}). Check your network connection and try again.`);
         }
+        // Reachable, but nothing published on this channel yet (e.g. a stable
+        // install while only betas exist). Not an error — just nothing to do.
+        if (result.version === null) {
+            logger.log(ui.info(`No newer release available on the ${result.channel} channel.`));
+            return;
+        }
+        const latest = result.version;
         if (!versionService.isOutdated(current, latest)) {
-            cli_1.logger.log(`${styling_1.symbols.success} Already on the latest version (${styling_1.colors.highlight(current)}).`);
+            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 cli_1.CliError(`No binary published for ${platformKey}. Supported platforms: ${Object.keys(ASSET_BY_PLATFORM).join(', ')}`);
+            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 cli_1.CliError(`Automatic upgrade on Windows is not yet supported. Re-run the installer:\n  irm ${base}/install.ps1 | iex`);
+            // Prerelease users need the beta channel opt-in or the installer resolves
+            // the (currently non-existent) stable release.
+            const betaHint = result.channel === 'beta' ? '$env:DCD_BETA=1; ' : '';
+            throw new CliError(`Automatic upgrade on Windows is not yet supported. Re-run the installer:\n  ${betaHint}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`;
-        cli_1.logger.log(`${styling_1.symbols.info} Upgrading ${styling_1.colors.highlight(current)} → ${styling_1.colors.highlight(latest)}`);
-        cli_1.logger.log(styling_1.colors.dim(`  ${binaryUrl}`));
+        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 {
@@ -72,16 +80,16 @@ exports.upgradeCommand = (0, citty_1.defineCommand)({
             if (expected !== actual) {
                 throw new Error(`Checksum mismatch for ${asset}: expected ${expected}, got ${actual}`);
             }
-            (0, node_fs_1.chmodSync)(tmpPath, 0o755);
+            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.
-            (0, node_fs_1.renameSync)(tmpPath, execPath);
+            renameSync(tmpPath, execPath);
         }
         catch (e) {
             safeUnlink(tmpPath);
-            throw new cli_1.CliError(`Upgrade failed: ${e.message}. The existing binary at ${execPath} was not modified.`);
+            throw new CliError(`Upgrade failed: ${e.message}. The existing binary at ${execPath} was not modified.`);
         }
-        cli_1.logger.log(`${styling_1.symbols.success} Upgraded to ${styling_1.colors.highlight(latest)}`);
+        logger.log(ui.success(`Upgraded to ${colors.highlight(latest)}`));
     },
 });
 async function downloadToFile(url, dest) {
@@ -90,7 +98,7 @@ async function downloadToFile(url, dest) {
         throw new Error(`HTTP ${res.status} fetching ${url}`);
     }
     // Node 22 exposes Readable.fromWeb for piping a WHATWG ReadableStream.
-    await (0, promises_1.pipeline)(node_stream_1.Readable.fromWeb(res.body), (0, node_fs_1.createWriteStream)(dest));
+    await pipeline(Readable.fromWeb(res.body), createWriteStream(dest));
 }
 async function fetchExpectedChecksum(sumsUrl, asset) {
     const res = await fetch(sumsUrl, { redirect: 'follow' });
@@ -105,18 +113,18 @@ async function fetchExpectedChecksum(sumsUrl, asset) {
     throw new Error(`SHA256SUMS has no entry for ${asset}`);
 }
 async function sha256File(path) {
-    const hash = (0, node_crypto_1.createHash)('sha256');
-    for await (const chunk of (0, node_fs_1.createReadStream)(path)) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(path)) {
         hash.update(chunk);
     }
     return hash.digest('hex');
 }
 function safeUnlink(path) {
     try {
-        (0, node_fs_1.unlinkSync)(path);
+        unlinkSync(path);
     }
     catch {
         // Best-effort cleanup; failure here would only leave a .new file.
     }
 }
-exports.default = exports.upgradeCommand;
+export default upgradeCommand;

package/dist/commands/upload.d.ts

@@ -1,32 +1,32 @@
 export declare const uploadCommand: import("citty").CommandDef<{
-    'app-url': {
+    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.";
     };
-    'ignore-sha-check': {
+    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)";
     };
-    debug: {
+    readonly debug: {
         readonly type: "boolean";
         readonly default: false;
         readonly description: "Enable detailed debug logging for troubleshooting issues";
     };
-    json: {
+    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";
     };
-    appFile: {
-        type: "positional";
-        required: false;
-        description: string;
+    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/...)";
     };
-    'api-key': {
+    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.";
     };
-    'api-url': {
+    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)";

package/dist/commands/upload.js

@@ -1,28 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadCommand = void 0;
-const citty_1 = require("citty");
-const promises_1 = require("node:fs/promises");
-const api_flags_1 = require("../config/flags/api.flags");
-const binary_flags_1 = require("../config/flags/binary.flags");
-const output_flags_1 = require("../config/flags/output.flags");
-const methods_1 = require("../methods");
-const auth_1 = require("../utils/auth");
-const cli_1 = require("../utils/cli");
-const config_store_1 = require("../utils/config-store");
-const expo_1 = require("../utils/expo");
-const styling_1 = require("../utils/styling");
-exports.uploadCommand = (0, citty_1.defineCommand)({
+import { defineCommand } from 'citty';
+import { rm } from 'node:fs/promises';
+import { apiFlags } from '../config/flags/api.flags.js';
+import { binaryFlags } from '../config/flags/binary.flags.js';
+import { outputFlags } from '../config/flags/output.flags.js';
+import { uploadBinary, verifyAppZip } from '../methods.js';
+import { resolveAuth } from '../utils/auth.js';
+import { CliError, logger } from '../utils/cli.js';
+import { resolveApiUrl } from '../utils/config-store.js';
+import { downloadExpoUrl, extractTarGz, findAppBundle, isUrl } from '../utils/expo.js';
+import { colors, formatId } from '../utils/styling.js';
+import { ui } from '../utils/ui.js';
+export const uploadCommand = defineCommand({
     meta: {
         name: 'upload',
         description: 'Upload an app binary to devicecloud.dev',
     },
     args: {
-        ...api_flags_1.apiFlags,
-        'app-url': binary_flags_1.binaryFlags['app-url'],
-        'ignore-sha-check': binary_flags_1.binaryFlags['ignore-sha-check'],
-        debug: output_flags_1.outputFlags.debug,
-        json: output_flags_1.outputFlags.json,
+        ...apiFlags,
+        'app-url': binaryFlags['app-url'],
+        'ignore-sha-check': binaryFlags['ignore-sha-check'],
+        debug: outputFlags.debug,
+        json: outputFlags.json,
         appFile: {
             type: 'positional',
             required: false,
@@ -35,45 +33,44 @@ exports.uploadCommand = (0, citty_1.defineCommand)({
         // When --json is set, suppress chatty progress logs so stdout stays parseable.
         const out = (m) => {
             if (!json)
-                cli_1.logger.log(m);
+                logger.log(m);
         };
         try {
             const apiKeyFlag = args['api-key'];
-            const apiUrl = (0, config_store_1.resolveApiUrl)(args['api-url']);
+            const apiUrl = resolveApiUrl(args['api-url']);
             const appUrl = args['app-url'];
             const ignoreShaCheck = Boolean(args['ignore-sha-check']);
             const debug = Boolean(args.debug);
             const positional = args.appFile;
-            const auth = await (0, auth_1.resolveAuth)({ apiKeyFlag });
+            const auth = await resolveAuth({ apiKeyFlag });
             let resolvedFile = appUrl ?? positional;
             if (!resolvedFile) {
-                throw new cli_1.CliError('You must provide an app file path or a signed Expo URL via --app-url');
+                throw new CliError('You must provide an app file path or a signed Expo URL via --app-url');
             }
-            if ((0, expo_1.isUrl)(resolvedFile)) {
-                out(`   ${styling_1.colors.dim('→ Downloading Expo build from URL...')}`);
-                const tarPath = await (0, expo_1.downloadExpoUrl)(resolvedFile, debug);
+            if (isUrl(resolvedFile)) {
+                out(ui.running('Downloading Expo build from URL…'));
+                const tarPath = await downloadExpoUrl(resolvedFile, debug);
                 tempFiles.push(tarPath);
                 resolvedFile = tarPath;
             }
             if (resolvedFile.endsWith('.tar.gz')) {
-                out(`   ${styling_1.colors.dim('→ Extracting Expo archive...')}`);
-                const extractDir = await (0, expo_1.extractTarGz)(resolvedFile, debug);
+                out(ui.running('Extracting Expo archive…'));
+                const extractDir = await extractTarGz(resolvedFile, debug);
                 tempFiles.push(extractDir);
-                resolvedFile = await (0, expo_1.findAppBundle)(extractDir);
+                resolvedFile = await findAppBundle(extractDir);
                 if (debug) {
                     out(`[DEBUG] Found .app bundle at: ${resolvedFile}`);
                 }
             }
             if (!['.apk', '.app', '.zip', '.tar.gz'].some((ext) => resolvedFile.endsWith(ext))) {
-                throw new cli_1.CliError('App file must be a .apk for Android, .app/.zip for iOS, or .tar.gz (Expo iOS build)');
+                throw new CliError('App file must be a .apk for Android, .app/.zip for iOS, or .tar.gz (Expo iOS build)');
             }
             if (resolvedFile.endsWith('.zip')) {
-                await (0, methods_1.verifyAppZip)(resolvedFile);
+                await verifyAppZip(resolvedFile);
             }
-            out((0, styling_1.sectionHeader)('Uploading app binary'));
-            out(`   ${styling_1.colors.dim('→ File:')} ${styling_1.colors.highlight(resolvedFile)}`);
-            out('');
-            const appBinaryId = await (0, methods_1.uploadBinary)({
+            out(ui.section('Uploading app binary'));
+            out(ui.branch(ui.fields([['file', colors.highlight(resolvedFile)]])));
+            const appBinaryId = await uploadBinary({
                 auth,
                 apiUrl,
                 debug,
@@ -86,19 +83,21 @@ exports.uploadCommand = (0, citty_1.defineCommand)({
                 console.log(JSON.stringify({ appBinaryId }, null, 2));
                 return;
             }
-            cli_1.logger.log(`\n${styling_1.symbols.success} ${styling_1.colors.bold('Upload complete')}`);
-            cli_1.logger.log(`   ${styling_1.colors.dim('Binary ID:')} ${(0, styling_1.formatId)(appBinaryId)}\n`);
-            cli_1.logger.log(styling_1.colors.dim('You can use this Binary ID in subsequent test runs with:'));
-            cli_1.logger.log(styling_1.colors.info(`dcd cloud --app-binary-id ${appBinaryId} path/to/flow.yaml\n`));
+            logger.log(`\n${ui.success('Upload complete')}`);
+            logger.log(ui.branch([
+                ...ui.fields([['binary id', formatId(appBinaryId)]]),
+                ui.note('Use this Binary ID in subsequent test runs with:'),
+                colors.info(`dcd cloud --app-binary-id ${appBinaryId} path/to/flow.yaml`),
+            ]));
         }
         catch (error) {
-            cli_1.logger.error(error, { exit: 1, json });
+            logger.error(error, { exit: 1, json });
         }
         finally {
             for (const p of tempFiles) {
-                await (0, promises_1.rm)(p, { recursive: true, force: true }).catch(() => { });
+                await rm(p, { recursive: true, force: true }).catch(() => { });
             }
         }
     },
 });
-exports.default = exports.uploadCommand;
+export default uploadCommand;

package/dist/commands/whoami.js

@@ -1,34 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.whoamiCommand = void 0;
 /**
  * `dcd whoami` — prints the logged-in user + active org from stored config.
  */
-const citty_1 = require("citty");
-const cli_1 = require("../utils/cli");
-const config_store_1 = require("../utils/config-store");
-const styling_1 = require("../utils/styling");
-exports.whoamiCommand = (0, citty_1.defineCommand)({
+import { defineCommand } from 'citty';
+import { logger } from '../utils/cli.js';
+import { readConfig } from '../utils/config-store.js';
+import { colors, formatId } from '../utils/styling.js';
+import { ui } from '../utils/ui.js';
+export const whoamiCommand = defineCommand({
     meta: {
         name: 'whoami',
         description: 'Show the logged-in user and active organization',
     },
     run() {
-        const config = (0, config_store_1.readConfig)();
+        const config = readConfig();
         if (!config?.session) {
-            cli_1.logger.log(`${styling_1.symbols.info} Not logged in. Run ${styling_1.colors.highlight('dcd login')} or set ${styling_1.colors.highlight('DEVICE_CLOUD_API_KEY')}.`);
+            logger.log(ui.info(`Not logged in. Run ${colors.highlight('dcd login')} or set ${colors.highlight('DEVICE_CLOUD_API_KEY')}.`));
             return;
         }
-        cli_1.logger.log((0, styling_1.sectionHeader)('devicecloud.dev'));
-        cli_1.logger.log(`   ${styling_1.colors.dim('User:')} ${styling_1.colors.highlight(config.session.user_email)}`);
-        if (config.current_org_name) {
-            cli_1.logger.log(`   ${styling_1.colors.dim('Org:')}  ${styling_1.colors.highlight(config.current_org_name)}`);
+        // Fallback for sessions stored before we persisted org name alongside id.
+        const org = config.current_org_name ?? config.current_org_id;
+        const fields = [['user', formatId(config.session.user_email)]];
+        if (org) {
+            fields.push(['org', formatId(org)]);
         }
-        else if (config.current_org_id) {
-            // Fallback for sessions stored before we persisted org name alongside id.
-            cli_1.logger.log(`   ${styling_1.colors.dim('Org:')}  ${styling_1.colors.highlight(config.current_org_id)}`);
-        }
-        cli_1.logger.log(`   ${styling_1.colors.dim('Env:')}  ${config.env}`);
+        fields.push(['env', config.env]);
+        logger.log(ui.section('devicecloud.dev'));
+        logger.log(ui.branch(ui.fields(fields)));
     },
 });
-exports.default = exports.whoamiCommand;
+export default whoamiCommand;

package/dist/config/environments.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Per-env devicecloud.dev coordinates — single source of truth for the URLs
  * and Supabase credentials the CLI uses.
@@ -9,12 +8,7 @@
  * them here — every Supabase-based product ships its anon key the same way.
  * https://supabase.com/docs/guides/api/api-keys
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENVIRONMENTS = void 0;
-exports.findEnvByApiUrl = findEnvByApiUrl;
-exports.inferEnvFromApiUrl = inferEnvFromApiUrl;
-exports.resolveFrontendUrl = resolveFrontendUrl;
-exports.ENVIRONMENTS = {
+export const ENVIRONMENTS = {
     prod: {
         apiUrl: 'https://api.devicecloud.dev',
         frontendUrl: 'https://console.devicecloud.dev',
@@ -35,13 +29,13 @@ exports.ENVIRONMENTS = {
     },
 };
 /** Exact-match lookup of a known environment by API URL (trailing slashes ignored). */
-function findEnvByApiUrl(apiUrl) {
+export function findEnvByApiUrl(apiUrl) {
     const normalize = (u) => u.replace(/\/+$/, '');
     const needle = normalize(apiUrl);
-    return Object.values(exports.ENVIRONMENTS).find((env) => normalize(env.apiUrl) === needle);
+    return Object.values(ENVIRONMENTS).find((env) => normalize(env.apiUrl) === needle);
 }
 /** Map a caller-supplied API URL to one of the known environments. */
-function inferEnvFromApiUrl(apiUrl) {
+export function inferEnvFromApiUrl(apiUrl) {
     if (apiUrl.includes('api.dev.') || apiUrl.includes('localhost'))
         return 'dev';
     return 'prod';
@@ -51,8 +45,8 @@ function inferEnvFromApiUrl(apiUrl) {
  * `ENVIRONMENTS[inferEnvFromApiUrl(apiUrl)].frontendUrl`, except that when the
  * API is running on localhost we assume the frontend is too (vite dev server).
  */
-function resolveFrontendUrl(apiUrl) {
+export function resolveFrontendUrl(apiUrl) {
     if (apiUrl.includes('localhost'))
         return 'http://localhost:5173';
-    return exports.ENVIRONMENTS[inferEnvFromApiUrl(apiUrl)].frontendUrl;
+    return ENVIRONMENTS[inferEnvFromApiUrl(apiUrl)].frontendUrl;
 }

package/dist/config/flags/api.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.apiFlags = void 0;
 /**
  * API authentication and configuration flags
  */
-exports.apiFlags = {
+export const apiFlags = {
     'api-key': {
         type: 'string',
         alias: ['apiKey'],

package/dist/config/flags/binary.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.binaryFlags = void 0;
 /**
  * Binary upload and management flags
  */
-exports.binaryFlags = {
+export const binaryFlags = {
     'app-binary-id': {
         type: 'string',
         description: 'The ID of the app binary previously uploaded to devicecloud.dev',

package/dist/config/flags/device.flags.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.deviceFlags = void 0;
-const device_types_1 = require("../../types/domain/device.types");
-const androidApiLevels = Object.values(device_types_1.EAndroidApiLevels).join(', ');
-const androidDevices = Object.values(device_types_1.EAndroidDevices).join(', ');
-const iosDevices = Object.values(device_types_1.EiOSDevices).join(', ');
-const iosVersions = Object.values(device_types_1.EiOSVersions).join(', ');
+import { EAndroidApiLevels, EAndroidDevices, EiOSDevices, EiOSVersions, } from '../../types/domain/device.types.js';
+const androidApiLevels = Object.values(EAndroidApiLevels).join(', ');
+const androidDevices = Object.values(EAndroidDevices).join(', ');
+const iosDevices = Object.values(EiOSDevices).join(', ');
+const iosVersions = Object.values(EiOSVersions).join(', ');
 /**
  * Device-specific flags for Android and iOS configuration
  */
-exports.deviceFlags = {
+export const deviceFlags = {
     'android-api-level': {
         type: 'string',
         description: `[Android only] Android API level to run your flow against (options: ${androidApiLevels})`,

package/dist/config/flags/environment.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.environmentFlags = void 0;
 /**
  * Environment configuration and metadata flags
  */
-exports.environmentFlags = {
+export const environmentFlags = {
     env: {
         type: 'string',
         alias: ['e'],

package/dist/config/flags/execution.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.executionFlags = void 0;
 /**
  * Test execution and flow management flags
  */
-exports.executionFlags = {
+export const executionFlags = {
     config: {
         type: 'string',
         description: 'Path to custom config.yaml file. If not provided, defaults to config.yaml in root flows folders.',

package/dist/config/flags/github.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.githubFlags = void 0;
 /**
  * GitHub context flags — stored as gh_* metadata alongside the run
  */
-exports.githubFlags = {
+export const githubFlags = {
     branch: {
         type: 'string',
         description: 'Git branch name for this run (stored as gh_branch metadata)',

package/dist/config/flags/output.flags.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.outputFlags = void 0;
 /**
  * Output format and artifact download flags
  */
-exports.outputFlags = {
+export const outputFlags = {
     'artifacts-path': {
         type: 'string',
         description: 'Custom file path for downloaded artifacts (default: ./artifacts.zip). Requires --download-artifacts.',

package/dist/constants.js

@@ -1,27 +1,24 @@
-"use strict";
 /**
  * Consolidated flag definitions.
  * Flags are organized by domain in src/config/flags/
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.flags = void 0;
-const api_flags_1 = require("./config/flags/api.flags");
-const binary_flags_1 = require("./config/flags/binary.flags");
-const device_flags_1 = require("./config/flags/device.flags");
-const environment_flags_1 = require("./config/flags/environment.flags");
-const execution_flags_1 = require("./config/flags/execution.flags");
-const github_flags_1 = require("./config/flags/github.flags");
-const output_flags_1 = require("./config/flags/output.flags");
+import { apiFlags } from './config/flags/api.flags.js';
+import { binaryFlags } from './config/flags/binary.flags.js';
+import { deviceFlags } from './config/flags/device.flags.js';
+import { environmentFlags } from './config/flags/environment.flags.js';
+import { executionFlags } from './config/flags/execution.flags.js';
+import { githubFlags } from './config/flags/github.flags.js';
+import { outputFlags } from './config/flags/output.flags.js';
 /**
  * All flag definitions consolidated from domain-specific flag modules.
  * Spread into a command's `args` to expose the full cloud-command surface.
  */
-exports.flags = {
-    ...api_flags_1.apiFlags,
-    ...binary_flags_1.binaryFlags,
-    ...device_flags_1.deviceFlags,
-    ...environment_flags_1.environmentFlags,
-    ...execution_flags_1.executionFlags,
-    ...github_flags_1.githubFlags,
-    ...output_flags_1.outputFlags,
+export const flags = {
+    ...apiFlags,
+    ...binaryFlags,
+    ...deviceFlags,
+    ...environmentFlags,
+    ...executionFlags,
+    ...githubFlags,
+    ...outputFlags,
 };

package/dist/gateways/api-gateway.d.ts

@@ -1,6 +1,7 @@
-import { TAppMetadata } from '../types';
-import type { AuthContext } from '../types/domain/auth.types';
-import type { LiveCommandStatus, LiveExecResult, LiveSession, LiveSessionSummary } from '../types/domain/live.types';
+import { TAppMetadata } from '../types.js';
+import type { AuthContext } from '../types/domain/auth.types.js';
+import type { LiveCommandStatus, LiveExecResult, LiveSession, LiveSessionSummary } from '../types/domain/live.types.js';
+import { components } from '../types/generated/schema.types.js';
 /**
  * Error thrown for non-OK API responses, carrying the HTTP status so callers
  * can branch on auth failures etc. without string matching.
@@ -51,13 +52,13 @@ export declare const ApiGateway: {
         tempPath: string;
         finalPath: string;
         id: string;
-        b2?: import("../types/generated/schema.types").components["schemas"]["B2UploadStrategy"];
+        b2?: components["schemas"]["B2UploadStrategy"];
         token?: string;
     }>;
     finishLargeFile(baseUrl: string, auth: AuthContext, fileId: string, partSha1Array: string[]): Promise<unknown>;
     getResultsForUpload(baseUrl: string, auth: AuthContext, uploadId: string): Promise<{
         statusCode?: number;
-        results?: import("../types/generated/schema.types").components["schemas"]["TResultResponse"][];
+        results?: components["schemas"]["TResultResponse"][];
     }>;
     getUploadStatus(baseUrl: string, auth: AuthContext, options: {
         name?: string;
@@ -93,7 +94,31 @@ export declare const ApiGateway: {
     }>;
     uploadFlow(baseUrl: string, auth: AuthContext, testFormData: FormData): Promise<{
         message?: string;
-        results?: import("../types/generated/schema.types").components["schemas"]["IDBResult"][];
+        results?: components["schemas"]["IDBResult"][];
+    }>;
+    /**
+     * Requests a storage URL for a client-direct flow zip upload. Mirrors
+     * `getBinaryUploadUrl` (same response shape) but stages the zip under
+     * `<orgId>/tests/` instead of the app-binary path. A 404 here means the API
+     * predates the client-direct flow path — callers fall back to `uploadFlow`.
+     */
+    getFlowUploadUrl(baseUrl: string, auth: AuthContext, fileSize: number): Promise<{
+        path: string;
+        tempPath: string;
+        finalPath: string;
+        id: string;
+        b2?: components["schemas"]["B2UploadStrategy"];
+        token?: string;
+    }>;
+    /**
+     * Submits a flow test that references an already-uploaded zip (JSON body, no
+     * multipart). The response is identical to the legacy `POST /uploads/flow`.
+     * A 404 means the API predates this endpoint — callers fall back to
+     * `uploadFlow`.
+     */
+    submitFlowTest(baseUrl: string, auth: AuthContext, body: Record<string, unknown>): Promise<{
+        message?: string;
+        results?: components["schemas"]["IDBResult"][];
     }>;
     /**
      * Generic report download method that handles both junit and allure reports