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

package/dist/methods.js

@@ -1,20 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDurationSeconds = exports.writeJSONFile = exports.uploadBinary = exports.verifyAppZip = exports.compressFilesFromRelativePath = void 0;
-const progress_1 = require("./utils/progress");
-const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const os = require("node:os");
-const path = require("node:path");
-const promises_2 = require("node:stream/promises");
-const StreamZip = require("node-stream-zip");
-const yazl = require("yazl");
-const environments_1 = require("./config/environments");
-const api_gateway_1 = require("./gateways/api-gateway");
-const supabase_gateway_1 = require("./gateways/supabase-gateway");
-const metadata_extractor_service_1 = require("./services/metadata-extractor.service");
-const styling_1 = require("./utils/styling");
+import { ux } from './utils/progress.js';
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream, mkdirSync, readdirSync, writeFileSync, } from 'node:fs';
+import { access, mkdtemp, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import StreamZip from 'node-stream-zip';
+import * as yazl from 'yazl';
+import { inferEnvFromApiUrl } from './config/environments.js';
+import { ApiError, ApiGateway } from './gateways/api-gateway.js';
+import { SupabaseGateway } from './gateways/supabase-gateway.js';
+import { MetadataExtractorService } from './services/metadata-extractor.service.js';
+import { colors, formatId } from './utils/styling.js';
 const mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
     yaml: 'application/x-yaml',
@@ -44,7 +41,7 @@ function toZipEntryName(relativePath) {
 async function compressFolderToTempZip(sourceDir) {
     const zipfile = new yazl.ZipFile();
     const rootName = path.basename(sourceDir);
-    const entries = (0, node_fs_1.readdirSync)(sourceDir, {
+    const entries = readdirSync(sourceDir, {
         recursive: true,
         withFileTypes: true,
     });
@@ -55,13 +52,13 @@ async function compressFolderToTempZip(sourceDir) {
         const relativePath = path.relative(sourceDir, absolutePath);
         zipfile.addFile(absolutePath, toZipEntryName(path.join(rootName, relativePath)));
     }
-    const tempDir = await (0, promises_1.mkdtemp)(path.join(os.tmpdir(), 'dcd-app-zip-'));
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'dcd-app-zip-'));
     const zipPath = path.join(tempDir, `${rootName}.zip`);
     zipfile.end();
-    await (0, promises_2.pipeline)(zipfile.outputStream, (0, node_fs_1.createWriteStream)(zipPath));
+    await pipeline(zipfile.outputStream, createWriteStream(zipPath));
     return { tempDir, zipPath };
 }
-const compressFilesFromRelativePath = async (basePath, files, commonRoot) => {
+export const compressFilesFromRelativePath = async (basePath, files, commonRoot) => {
     const zipfile = new yazl.ZipFile();
     for (const file of files) {
         // Anchored prefix strip — replace() would remove the first occurrence
@@ -70,8 +67,7 @@ const compressFilesFromRelativePath = async (basePath, files, commonRoot) => {
     }
     return zipToBuffer(zipfile);
 };
-exports.compressFilesFromRelativePath = compressFilesFromRelativePath;
-const verifyAppZip = async (zipPath) => {
+export const verifyAppZip = async (zipPath) => {
     // eslint-disable-next-line import/namespace, new-cap
     const zip = await new StreamZip.async({
         file: zipPath,
@@ -96,11 +92,10 @@ const verifyAppZip = async (zipPath) => {
         zip.close();
     }
 };
-exports.verifyAppZip = verifyAppZip;
-const uploadBinary = async (config) => {
+export const uploadBinary = async (config) => {
     const { filePath, apiUrl, auth, ignoreShaCheck = false, log = true, debug = false } = config;
     if (log) {
-        progress_1.ux.action.start(styling_1.colors.bold('Checking and uploading binary'), styling_1.colors.dim('Initializing'), {
+        ux.action.start(colors.bold('Checking and uploading binary'), colors.dim('Initializing'), {
             stdout: true,
         });
     }
@@ -122,8 +117,8 @@ const uploadBinary = async (config) => {
             const { exists, binaryId } = await checkExistingUpload(apiUrl, auth, sha, debug);
             if (exists && binaryId) {
                 if (log) {
-                    progress_1.ux.info(styling_1.colors.dim('SHA hash matches existing binary with ID: ') + (0, styling_1.formatId)(binaryId) + styling_1.colors.dim(', skipping upload. Force upload with --ignore-sha-check'));
-                    progress_1.ux.action.stop(styling_1.colors.info('Skipping upload'));
+                    ux.info(colors.dim('SHA hash matches existing binary with ID: ') + formatId(binaryId) + colors.dim(', skipping upload. Force upload with --ignore-sha-check'));
+                    ux.action.stop(colors.info('Skipping upload'));
                 }
                 return binaryId;
             }
@@ -131,13 +126,13 @@ const uploadBinary = async (config) => {
         // Perform the upload
         const uploadId = await performUpload({ auth, apiUrl, debug, filePath, sha, source, startTime });
         if (log) {
-            progress_1.ux.action.stop(styling_1.colors.success('\n✓ Binary uploaded with ID: ') + (0, styling_1.formatId)(uploadId));
+            ux.action.stop(colors.success('\n✓ Binary uploaded with ID: ') + formatId(uploadId));
         }
         return uploadId;
     }
     catch (error) {
         if (log) {
-            progress_1.ux.action.stop(styling_1.colors.error('✗ Failed'));
+            ux.action.stop(colors.error('✗ Failed'));
         }
         if (debug) {
             console.error('[DEBUG] === BINARY UPLOAD FAILED ===');
@@ -153,11 +148,10 @@ const uploadBinary = async (config) => {
     }
     finally {
         if (source?.cleanupDir) {
-            await (0, promises_1.rm)(source.cleanupDir, { recursive: true, force: true }).catch(() => { });
+            await rm(source.cleanupDir, { recursive: true, force: true }).catch(() => { });
         }
     }
 };
-exports.uploadBinary = uploadBinary;
 /**
  * Prepares a file for upload: .app directories are zipped to a temp file on
  * disk; everything else is described in place. Nothing is read into memory.
@@ -178,7 +172,7 @@ async function prepareFileForUpload(filePath, debug, startTime) {
         // Validate that the .app directory exists before attempting to compress —
         // zipping a non-existent path silently produces an empty 22-byte zip.
         try {
-            await (0, promises_1.access)(filePath);
+            await access(filePath);
         }
         catch {
             // Provide helpful error message for common quoting issues
@@ -201,7 +195,7 @@ async function prepareFileForUpload(filePath, debug, startTime) {
             throw new Error(errorMessage);
         }
         const { tempDir, zipPath } = await compressFolderToTempZip(filePath);
-        const { size } = await (0, promises_1.stat)(zipPath);
+        const { size } = await stat(zipPath);
         source = {
             contentType: 'application/zip',
             cleanupDir: tempDir,
@@ -214,7 +208,7 @@ async function prepareFileForUpload(filePath, debug, startTime) {
         }
     }
     else {
-        const { size } = await (0, promises_1.stat)(filePath);
+        const { size } = await stat(filePath);
         if (debug) {
             console.log(`[DEBUG] File size: ${(size / 1024 / 1024).toFixed(2)} MB`);
         }
@@ -276,7 +270,7 @@ async function checkExistingUpload(apiUrl, auth, sha, debug) {
             console.log(`[DEBUG] Target endpoint: ${apiUrl}/uploads/checkForExistingUpload`);
         }
         const shaCheckStartTime = Date.now();
-        const { appBinaryId, exists } = await api_gateway_1.ApiGateway.checkForExistingUpload(apiUrl, auth, sha);
+        const { appBinaryId, exists } = await ApiGateway.checkForExistingUpload(apiUrl, auth, sha);
         if (debug) {
             console.log(`[DEBUG] SHA check completed in ${Date.now() - shaCheckStartTime}ms`);
             console.log(`[DEBUG] Existing binary found: ${exists}`);
@@ -289,7 +283,7 @@ async function checkExistingUpload(apiUrl, auth, sha, debug) {
     catch (error) {
         // Invalid credentials will fail every subsequent request — surface now
         // rather than after the user has waited through a potentially huge upload.
-        if (error instanceof api_gateway_1.ApiError && (error.status === 401 || error.status === 403)) {
+        if (error instanceof ApiError && (error.status === 401 || error.status === 403)) {
             throw error;
         }
         if (debug) {
@@ -325,7 +319,7 @@ async function uploadToSupabase(env, tempPath, source, debug) {
     }
     try {
         const uploadStartTime = Date.now();
-        await supabase_gateway_1.SupabaseGateway.uploadResumable(env, tempPath, source, debug);
+        await SupabaseGateway.uploadResumable(env, tempPath, source, debug);
         if (debug) {
             const uploadDuration = Date.now() - uploadStartTime;
             const uploadDurationSeconds = uploadDuration / 1000;
@@ -428,7 +422,7 @@ async function requestUploadPaths(apiUrl, auth, filePath, fileSize, debug) {
     }
     try {
         const urlRequestStartTime = Date.now();
-        const { id, tempPath, finalPath, b2 } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, auth, platform, fileSize);
+        const { id, tempPath, finalPath, b2 } = await ApiGateway.getBinaryUploadUrl(apiUrl, auth, platform, fileSize);
         if (debug) {
             const hasStrategy = b2 && typeof b2 === 'object' && 'strategy' in b2;
             console.log(`[DEBUG] Upload URL request completed in ${Date.now() - urlRequestStartTime}ms`);
@@ -451,9 +445,11 @@ async function requestUploadPaths(apiUrl, auth, filePath, fileSize, debug) {
         // Add context to the error
         if (error instanceof Error) {
             if (error.name === 'NetworkError') {
-                throw new Error(`Failed to request upload URL from API.\n\n${error.message}`);
+                throw new Error(`Failed to request upload URL from API.\n\n${error.message}`, { cause: error });
             }
-            throw new Error(`Failed to request upload URL: ${error.message}`);
+            throw new Error(`Failed to request upload URL: ${error.message}`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -467,7 +463,7 @@ async function requestUploadPaths(apiUrl, auth, filePath, fileSize, debug) {
 async function extractBinaryMetadata(filePath, debug) {
     if (debug)
         console.log('[DEBUG] Extracting app metadata...');
-    const metadataExtractor = new metadata_extractor_service_1.MetadataExtractorService();
+    const metadataExtractor = new MetadataExtractorService();
     const metadata = await metadataExtractor.extract(filePath);
     if (!metadata) {
         throw new Error(`Failed to extract metadata from ${filePath}. Supported formats: .apk, .app, .zip`);
@@ -513,7 +509,7 @@ async function performUpload(config) {
     const { id, tempPath, finalPath, b2 } = await requestUploadPaths(apiUrl, auth, filePath, source.size, debug);
     // Extract app metadata
     const metadata = await extractBinaryMetadata(filePath, debug);
-    const env = (0, environments_1.inferEnvFromApiUrl)(apiUrl);
+    const env = inferEnvFromApiUrl(apiUrl);
     // Upload to Backblaze first (primary)
     const backblazeResult = await handleBackblazeUpload({
         auth,
@@ -525,11 +521,10 @@ async function performUpload(config) {
     });
     let lastError = backblazeResult.error;
     // Always upload to Supabase (re-enabled as always-on alongside Backblaze)
-    let supabaseResult = { error: null, success: false };
     if (debug) {
         console.log('[DEBUG] Uploading to Supabase...');
     }
-    supabaseResult = await uploadToSupabase(env, tempPath, source, debug);
+    const supabaseResult = await uploadToSupabase(env, tempPath, source, debug);
     if (!supabaseResult.success && supabaseResult.error) {
         lastError = supabaseResult.error;
     }
@@ -549,7 +544,7 @@ async function performUpload(config) {
     }
     // Finalize upload
     const finalizeStartTime = Date.now();
-    await api_gateway_1.ApiGateway.finaliseUpload({
+    await ApiGateway.finaliseUpload({
         auth,
         backblazeSuccess: backblazeResult.success,
         baseUrl: apiUrl,
@@ -567,6 +562,70 @@ async function performUpload(config) {
     }
     return id;
 }
+/**
+ * Uploads an already-built flow zip directly to storage, mirroring the binary
+ * client-direct path: getFlowUploadUrl → upload to storage (Backblaze if
+ * offered + TUS to Supabase) → return the storage reference for submitFlowTest.
+ *
+ * The zip arrives as an in-memory Buffer (from `compressFilesFromRelativePath`);
+ * it's written to a temp file so the exact same disk-streaming uploaders the
+ * binary path uses can be reused unchanged. `supabaseSuccess`/`backblazeSuccess`
+ * are reported honestly based on which uploads succeeded.
+ *
+ * Errors from `getFlowUploadUrl` propagate untouched so callers can detect a
+ * 404 from an older API and fall back to the legacy multipart endpoint.
+ */
+export const uploadFlowZip = async (config) => {
+    const { apiUrl, auth, buffer, debug = false } = config;
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'dcd-flow-zip-'));
+    const diskPath = path.join(tempDir, 'flowFile.zip');
+    try {
+        await writeFile(diskPath, buffer);
+        const source = {
+            contentType: 'application/zip',
+            diskPath,
+            name: 'flowFile.zip',
+            size: buffer.length,
+        };
+        // Same response shape as getBinaryUploadUrl. A 404 here means the API
+        // predates the client-direct flow path — let it propagate so the caller
+        // falls back to the multipart endpoint.
+        const { id, tempPath, finalPath, b2 } = await ApiGateway.getFlowUploadUrl(apiUrl, auth, buffer.length);
+        if (!tempPath)
+            throw new Error('No upload path provided by API');
+        const env = inferEnvFromApiUrl(apiUrl);
+        // Upload to Backblaze first (primary, if configured)
+        const backblazeResult = await handleBackblazeUpload({
+            auth,
+            apiUrl,
+            b2: b2,
+            debug,
+            finalPath,
+            source,
+        });
+        let lastError = backblazeResult.error;
+        // Always upload to Supabase (always-on alongside Backblaze)
+        const supabaseResult = await uploadToSupabase(env, tempPath, source, debug);
+        if (!supabaseResult.success && supabaseResult.error) {
+            lastError = supabaseResult.error;
+        }
+        validateUploadResults(supabaseResult.success, backblazeResult.success, lastError, b2, debug);
+        if (debug) {
+            console.log(`[DEBUG] Flow zip upload summary - Backblaze: ${backblazeResult.success ? '✓' : '✗'}, Supabase: ${supabaseResult.success ? '✓' : '✗'}`);
+        }
+        return {
+            backblazeSuccess: backblazeResult.success,
+            bytes: buffer.length,
+            id,
+            path: tempPath,
+            supabaseSuccess: supabaseResult.success,
+            useTus: true,
+        };
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true }).catch(() => { });
+    }
+};
 /**
  * Upload file to Backblaze using signed URL (simple upload for files < 100MB)
  * @param uploadUrl - Backblaze upload URL
@@ -582,9 +641,9 @@ async function uploadToBackblaze(uploadUrl, authorizationToken, fileName, source
         // get the multi-part path), so one transient buffer here is bounded.
         // S3 pre-signed PUTs reject chunked transfer encoding, which rules out a
         // plain stream body.
-        const body = await (0, promises_1.readFile)(source.diskPath);
+        const body = await readFile(source.diskPath);
         // Calculate SHA1 hash for Backblaze (B2 requires SHA1, not SHA256)
-        const sha1 = (0, node_crypto_1.createHash)('sha1');
+        const sha1 = createHash('sha1');
         sha1.update(body);
         const sha1Hex = sha1.digest('hex');
         // Detect if this is an S3 pre-signed URL (authorization token is empty)
@@ -617,8 +676,9 @@ async function uploadToBackblaze(uploadUrl, authorizationToken, fileName, source
             if (debug) {
                 console.error(`[DEBUG] Backblaze upload failed with status ${response.status}: ${errorText}`);
             }
-            // Don't throw - we don't want Backblaze failures to block the primary upload
-            console.warn(`Warning: Backblaze upload failed with status ${response.status}`);
+            // Don't throw and don't warn — Backblaze is the primary attempt and the
+            // Supabase fallback usually recovers. A user-facing error is raised only
+            // if every strategy fails (see validateUploadResults).
             return false;
         }
         if (debug) {
@@ -641,12 +701,9 @@ async function uploadToBackblaze(uploadUrl, authorizationToken, fileName, source
             if (debug) {
                 console.error('[DEBUG] Network error detected - could be DNS, connection, or SSL issue');
             }
-            console.warn('Warning: Backblaze upload failed due to network error');
-        }
-        else {
-            // Don't throw - we don't want Backblaze failures to block the primary upload
-            console.warn(`Warning: Backblaze upload failed: ${error instanceof Error ? error.message : String(error)}`);
         }
+        // Don't throw and don't warn — the Supabase fallback usually recovers, and
+        // validateUploadResults raises a user-facing error only if all fail.
         return false;
     }
 }
@@ -660,7 +717,7 @@ async function uploadToBackblaze(uploadUrl, authorizationToken, fileName, source
 async function readFileChunk(filePath, start, end) {
     return new Promise((resolve, reject) => {
         const chunks = [];
-        const stream = (0, node_fs_1.createReadStream)(filePath, { start, end: end - 1 }); // end is inclusive in createReadStream
+        const stream = createReadStream(filePath, { start, end: end - 1 }); // end is inclusive in createReadStream
         stream.on('data', (chunk) => {
             chunks.push(chunk);
         });
@@ -678,7 +735,7 @@ async function readFileChunk(filePath, start, end) {
  * @returns SHA1 hash as hex string
  */
 function calculateSha1(buffer) {
-    const sha1 = (0, node_crypto_1.createHash)('sha1');
+    const sha1 = createHash('sha1');
     sha1.update(buffer);
     return sha1.digest('hex');
 }
@@ -716,7 +773,9 @@ async function uploadPartToBackblaze(config) {
             if (debug) {
                 console.error(`[DEBUG] Network error uploading part ${partNumber} - could be DNS, connection, or SSL issue`);
             }
-            throw new Error(`Part ${partNumber} upload failed due to network error`);
+            throw new Error(`Part ${partNumber} upload failed due to network error`, {
+                cause: error,
+            });
         }
         throw error;
     }
@@ -740,12 +799,9 @@ function logBackblazeUploadError(error, debug) {
             console.error(`[DEBUG] Stack trace:\n${error.stack}`);
         }
     }
-    if (error instanceof Error && error.message.includes('network error')) {
-        console.warn('Warning: Backblaze large file upload failed due to network error');
-    }
-    else {
-        console.warn(`Warning: Backblaze large file upload failed: ${error instanceof Error ? error.message : String(error)}`);
-    }
+    // No user-facing warning: Backblaze is the primary attempt and the Supabase
+    // fallback usually recovers; validateUploadResults raises the only
+    // user-facing error, and only when every strategy fails.
 }
 /**
  * Upload large file to Backblaze using multi-part upload with streaming (for files >= 5MB)
@@ -790,7 +846,7 @@ async function uploadLargeFileToBackblaze(config) {
             console.log('[DEBUG] Finishing large file upload...');
             console.log(`[DEBUG] Finalizing ${partSha1Array.length} parts with fileId: ${fileId}`);
         }
-        await api_gateway_1.ApiGateway.finishLargeFile(apiUrl, auth, fileId, partSha1Array);
+        await ApiGateway.finishLargeFile(apiUrl, auth, fileId, partSha1Array);
         if (debug)
             console.log('[DEBUG] Large file upload completed successfully');
         return true;
@@ -801,8 +857,8 @@ async function uploadLargeFileToBackblaze(config) {
     }
 }
 async function getFileHashFromPath(filePath) {
-    const hash = (0, node_crypto_1.createHash)('sha256');
-    for await (const chunk of (0, node_fs_1.createReadStream)(filePath)) {
+    const hash = createHash('sha256');
+    for await (const chunk of createReadStream(filePath)) {
         hash.update(chunk);
     }
     return hash.digest('hex');
@@ -814,37 +870,36 @@ async function getFileHashFromPath(filePath) {
  * @param logger - Logger object with log and warn methods
  * @returns true if successful, false if an error occurred
  */
-const writeJSONFile = (filePath, data, logger) => {
+export const writeJSONFile = (filePath, data, logger) => {
     try {
         const directory = path.dirname(filePath);
         if (directory !== '.') {
-            (0, node_fs_1.mkdirSync)(directory, { recursive: true });
+            mkdirSync(directory, { recursive: true });
         }
-        (0, node_fs_1.writeFileSync)(filePath, JSON.stringify(data, null, 2));
-        logger.log(styling_1.colors.dim('JSON output written to: ') + styling_1.colors.highlight(path.resolve(filePath)));
+        writeFileSync(filePath, JSON.stringify(data, null, 2));
+        logger.log(colors.dim('JSON output written to: ') + colors.highlight(path.resolve(filePath)));
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         const isPermissionError = errorMessage.includes('EACCES') || errorMessage.includes('EPERM');
         const isNoSuchFileError = errorMessage.includes('ENOENT');
-        logger.warn(styling_1.colors.error(`Failed to write JSON output to file: ${filePath}`));
+        logger.warn(colors.error(`Failed to write JSON output to file: ${filePath}`));
         if (isPermissionError) {
-            logger.warn(styling_1.colors.dim('   Permission denied - check file/directory write permissions'));
-            logger.warn(styling_1.colors.dim('   Try running with appropriate permissions or choose a different output location'));
+            logger.warn(colors.dim('   Permission denied - check file/directory write permissions'));
+            logger.warn(colors.dim('   Try running with appropriate permissions or choose a different output location'));
         }
         else if (isNoSuchFileError) {
-            logger.warn(styling_1.colors.dim('   Directory does not exist - create the directory first or choose an existing path'));
+            logger.warn(colors.dim('   Directory does not exist - create the directory first or choose an existing path'));
         }
-        logger.warn(styling_1.colors.dim('   Error details: ') + errorMessage);
+        logger.warn(colors.dim('   Error details: ') + errorMessage);
     }
 };
-exports.writeJSONFile = writeJSONFile;
 /**
  * Formats duration in seconds into a human readable string
  * @param durationSeconds - Duration in seconds
  * @returns Formatted duration string (e.g. "2m 30s" or "45s")
  */
-const formatDurationSeconds = (durationSeconds) => {
+export const formatDurationSeconds = (durationSeconds) => {
     const minutes = Math.floor(durationSeconds / 60);
     const seconds = durationSeconds % 60;
     if (minutes > 0) {
@@ -852,4 +907,3 @@ const formatDurationSeconds = (durationSeconds) => {
     }
     return `${durationSeconds}s`;
 };
-exports.formatDurationSeconds = formatDurationSeconds;

package/dist/services/device-validation.service.d.ts

@@ -1,4 +1,4 @@
-import { CompatibilityData } from '../utils/compatibility';
+import { CompatibilityData } from '../utils/compatibility.js';
 export interface DeviceValidationOptions {
     debug?: boolean;
     logger?: (message: string) => void;

package/dist/services/device-validation.service.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceValidationService = void 0;
 /**
  * Service for validating device configurations against compatibility data
  */
-class DeviceValidationService {
+export class DeviceValidationService {
     /**
      * Validate Android device configuration
      * @param androidApiLevel Android API level to validate
@@ -91,4 +88,3 @@ class DeviceValidationService {
         }
     }
 }
-exports.DeviceValidationService = DeviceValidationService;

package/dist/services/execution-plan.service.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.plan = plan;
-const fs = require("node:fs");
-const path = require("node:path");
-const execution_plan_utils_1 = require("./execution-plan.utils");
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getFlowsToRunInSequence, isFlowFile, processDependencies, readDirectory, readTestYamlFileAsJson, readYamlFileAsJson, } from './execution-plan.utils.js';
 /**
  * Recursively check and resolve all dependencies for a flow file
  * Includes runFlow references, JavaScript scripts, and media files
@@ -16,8 +13,8 @@ async function checkDependencies(input) {
     const uncheckedDependencies = [input];
     while (uncheckedDependencies.length > 0) {
         const fileToCheck = uncheckedDependencies.shift();
-        const { config, testSteps } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(fileToCheck);
-        const { allErrors, allFiles } = (0, execution_plan_utils_1.processDependencies)({
+        const { config, testSteps } = readTestYamlFileAsJson(fileToCheck);
+        const { allErrors, allFiles } = processDependencies({
             config,
             input: fileToCheck,
             testSteps,
@@ -27,7 +24,7 @@ async function checkDependencies(input) {
                 allErrors.join('\n'));
         }
         for (const file of allFiles) {
-            if (!(0, execution_plan_utils_1.isFlowFile)(file)) {
+            if (!isFlowFile(file)) {
                 // js/media files don't have dependencies
                 checkedDependencies.push(file);
             }
@@ -63,7 +60,7 @@ function getWorkspaceConfig(input, unfilteredFlowFiles) {
     const possibleConfigPaths = new Set([path.join(input, 'config.yaml'), path.join(input, 'config.yml')].map((p) => path.normalize(p)));
     const configFilePath = unfilteredFlowFiles.find((file) => possibleConfigPaths.has(path.normalize(file)));
     const config = configFilePath
-        ? (0, execution_plan_utils_1.readYamlFileAsJson)(configFilePath)
+        ? readYamlFileAsJson(configFilePath)
         : {};
     return config;
 }
@@ -99,7 +96,7 @@ async function planSingleFile(normalizedInput, configFile) {
         normalizedInput.endsWith('config.yml')) {
         throw new Error('If using config.yaml, pass the workspace folder path, not the config file or a custom path via --config');
     }
-    const { config } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(normalizedInput);
+    const { config } = readTestYamlFileAsJson(normalizedInput);
     const flowMetadata = {};
     const flowOverrides = {};
     if (config) {
@@ -112,7 +109,7 @@ async function planSingleFile(normalizedInput, configFile) {
         if (!fs.existsSync(configFilePath)) {
             throw new Error(`Config file does not exist: ${configFilePath}`);
         }
-        workspaceConfig = (0, execution_plan_utils_1.readYamlFileAsJson)(configFilePath);
+        workspaceConfig = readYamlFileAsJson(configFilePath);
     }
     const checkedDependancies = await checkDependencies(normalizedInput);
     return {
@@ -193,7 +190,7 @@ function resolveSequentialFlows(workspaceConfig, pathsByName, debug) {
             if (debug && flowOrder !== normalizedFlowOrder) {
                 console.log(`[DEBUG] Stripping trailing extension: "${flowOrder}" -> "${normalizedFlowOrder}"`);
             }
-            return (0, execution_plan_utils_1.getFlowsToRunInSequence)(pathsByName, [normalizedFlowOrder], debug);
+            return getFlowsToRunInSequence(pathsByName, [normalizedFlowOrder], debug);
         })),
     ];
     if (debug) {
@@ -225,7 +222,7 @@ function resolveSequentialFlows(workspaceConfig, pathsByName, debug) {
  * @returns Complete execution plan with flows, dependencies, and metadata
  * @throws Error if input path doesn't exist, no flows found, or dependencies missing
  */
-async function plan(options) {
+export async function plan(options) {
     const { input, includeTags = [], excludeTags = [], excludeFlows, configFile, debug = false, } = options;
     const normalizedInput = path.normalize(input);
     const flowMetadata = {};
@@ -235,7 +232,7 @@ async function plan(options) {
     if (fs.lstatSync(normalizedInput).isFile()) {
         return planSingleFile(normalizedInput, configFile);
     }
-    let unfilteredFlowFiles = await (0, execution_plan_utils_1.readDirectory)(normalizedInput, execution_plan_utils_1.isFlowFile);
+    let unfilteredFlowFiles = await readDirectory(normalizedInput, isFlowFile);
     if (unfilteredFlowFiles.length === 0) {
         throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(normalizedInput)}`);
     }
@@ -246,7 +243,7 @@ async function plan(options) {
         if (!fs.existsSync(configFilePath)) {
             throw new Error(`Config file does not exist: ${configFilePath}`);
         }
-        workspaceConfig = (0, execution_plan_utils_1.readYamlFileAsJson)(configFilePath);
+        workspaceConfig = readYamlFileAsJson(configFilePath);
     }
     else {
         workspaceConfig = getWorkspaceConfig(normalizedInput, unfilteredFlowFiles);
@@ -260,7 +257,7 @@ async function plan(options) {
     }
     // eslint-disable-next-line unicorn/no-array-reduce
     const configPerFlowFile = unfilteredFlowFiles.reduce((acc, filePath) => {
-        const { config } = (0, execution_plan_utils_1.readTestYamlFileAsJson)(filePath);
+        const { config } = readTestYamlFileAsJson(filePath);
         acc[filePath] = config;
         return acc;
     }, {});