@devicecloud.dev/dcd 0.0.2 → 0.0.4

package/dist/commands/cloud.d.ts

@@ -1,4 +1,21 @@
 import { Command } from '@oclif/core';
+export declare enum EiOSDevices {
+    'ipad-pro-6th-gen' = "ipad-pro-6th-gen",
+    'iphone-12' = "iphone-12",
+    'iphone-12-mini' = "iphone-12-mini",
+    'iphone-12-pro-max' = "iphone-12-pro-max",
+    'iphone-13' = "iphone-13",
+    'iphone-13-mini' = "iphone-13-mini",
+    'iphone-13-pro-max' = "iphone-13-pro-max",
+    'iphone-14' = "iphone-14",
+    'iphone-14-plus' = "iphone-14-plus",
+    'iphone-14-pro' = "iphone-14-pro",
+    'iphone-14-pro-max' = "iphone-14-pro-max",
+    'iphone-15' = "iphone-15",
+    'iphone-15-plus' = "iphone-15-plus",
+    'iphone-15-pro' = "iphone-15-pro",
+    'iphone-15-pro-max' = "iphone-15-pro-max"
+}
 export default class Cloud extends Command {
     static args: {
         firstFile: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;

package/dist/commands/cloud.js

@@ -1,91 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.EiOSDevices = void 0;
 /* eslint-disable complexity */
 const core_1 = require("@oclif/core");
 const cli_ux_1 = require("@oclif/core/lib/cli-ux");
 const errors_1 = require("@oclif/core/lib/errors");
-const archiver = require("archiver");
 const promises_1 = require("node:fs/promises");
-const node_stream_1 = require("node:stream");
+const path = require("node:path");
+const constants_1 = require("../constants");
+const methods_1 = require("../methods");
 const plan_1 = require("../plan");
 const mimeTypeLookupByExtension = {
     apk: 'application/vnd.android.package-archive',
     yaml: 'application/x-yaml',
     zip: 'application/zip',
 };
-const PERMITTED_EXTENSIONS = new Set([
-    'yml',
-    'yaml',
-    'png',
-    'jpg',
-    'jpeg',
-    'gif',
-    'mp4',
-    'js',
-]);
-const typeSafePost = async (baseUrl, path, init) => {
-    const res = await fetch(baseUrl + path, { ...init, method: 'POST' });
-    if (!res.ok) {
-        throw new Error(await res.text());
-    }
-    return res.json();
-};
-const typeSafeGet = async (baseUrl, path, init) => {
-    const res = await fetch(baseUrl + path, init);
-    if (!res.ok) {
-        throw new Error(await res.text());
-    }
-    return res.json();
-};
-const toBuffer = async (archive) => {
-    const chunks = [];
-    const writable = new node_stream_1.Writable();
-    writable._write = (chunk, _, callback) => {
-        // save to array to concatenate later
-        chunks.push(chunk);
-        callback();
-    };
-    // pipe to writable
-    archive.pipe(writable);
-    await archive.finalize();
-    // once done, concatenate chunks
-    return Buffer.concat(chunks);
-};
-const compressDir = async (sourceDir) => {
-    // const output = createWriteStream(zipTargetPath);
-    const archive = archiver('zip', {
-        zlib: { level: 9 },
-    });
-    archive.on('error', (err) => {
-        throw err;
-    });
-    archive.directory(sourceDir, '.', (data) => {
-        if (data.name.split('/')[0] === 'node_modules')
-            return false;
-        if (PERMITTED_EXTENSIONS.has(data.name.split('.').pop())) {
-            return data;
-        }
-        return false;
-    });
-    const buffer = await toBuffer(archive);
-    // await writeFile('./my-zip.zip', buffer);
-    return buffer;
-};
-// const compressFile = async (sourceFile: string) => {
-//   const archive = archiver('zip', {
-//     zlib: { level: 9 },
-//   });
-//   archive.on('error', (err) => {
-//     throw err;
-//   });
-//   console.log(sourceFile, sourceFile.split('/').pop());
-//   archive.file(sourceFile.includes('/') ? sourceFile : './' + sourceFile, {
-//     name: sourceFile.split('/').pop()!,
-//   });
-//   const buffer = await toBuffer(archive);
-//   await writeFile('./my-file-zip.zip', buffer);
-//   return buffer;
-// };
 var EiOSDevices;
 (function (EiOSDevices) {
     EiOSDevices["ipad-pro-6th-gen"] = "ipad-pro-6th-gen";
@@ -103,7 +32,7 @@ var EiOSDevices;
     EiOSDevices["iphone-15-plus"] = "iphone-15-plus";
     EiOSDevices["iphone-15-pro"] = "iphone-15-pro";
     EiOSDevices["iphone-15-pro-max"] = "iphone-15-pro-max";
-})(EiOSDevices || (EiOSDevices = {}));
+})(EiOSDevices || (exports.EiOSDevices = EiOSDevices = {}));
 class Cloud extends core_1.Command {
     static args = {
         firstFile: core_1.Args.string({
@@ -119,109 +48,10 @@ class Cloud extends core_1.Command {
     };
     static description = `Test a Flow or set of Flows on devicecloud.dev (https://devicecloud.dev)\nProvide your application file and a folder with Maestro flows to run them in parallel on multiple devices in devicecloud.dev\nThe command will block until all analyses have completed`;
     static examples = ['<%= config.bin %> <%= command.id %>'];
-    static flags = {
-        'android-api-level': core_1.Flags.integer({
-            description: '[Android only] Android API level to run your flow against',
-            options: ['32', '33', '34'],
-        }),
-        'android-device': core_1.Flags.string({
-            description: '[Android only] Android device to run your flow against',
-            options: [
-                'pixel-6',
-                'pixel-6a',
-                'pixel-6-pro',
-                'pixel-7',
-                'pixel-7-pro',
-                'generic-tablet',
-            ],
-        }),
-        apiKey: core_1.Flags.string({
-            aliases: ['api-key'],
-            description: 'API key',
-        }),
-        apiUrl: core_1.Flags.string({
-            aliases: ['api-url', 'apiURL'],
-            default: 'https://api.devicecloud.dev',
-            description: 'API base URL',
-            hidden: true,
-        }),
-        'app-binary-id': core_1.Flags.string({
-            aliases: ['app-binary-id'],
-            description: 'The ID of the app binary previously uploaded to Maestro Cloud',
-        }),
-        'app-file': core_1.Flags.file({
-            aliases: ['app-file'],
-            description: 'App binary to run your flows against',
-        }),
-        arm64: core_1.Flags.boolean({
-            default: false,
-            description: '[Android only] Run your flow against arm64 devices',
-        }),
-        async: core_1.Flags.boolean({
-            description: 'Wait for the results of the run',
-        }),
-        env: core_1.Flags.file({
-            char: 'e',
-            description: 'One or more environment variables to inject into your flows',
-            multiple: true,
-        }),
-        'exclude-tags': core_1.Flags.string({
-            aliases: ['exclude-tags'],
-            default: [],
-            description: 'Flows which have these tags will be excluded from the run',
-            multiple: true,
-            parse: (input) => input.split(','),
-        }),
-        flows: core_1.Flags.string({
-            description: 'The path to the flow file or folder containing your flows',
-        }),
-        'google-play': core_1.Flags.boolean({
-            aliases: ['google-play'],
-            default: false,
-            description: '[Android only] Run your flow against Google Play devices',
-        }),
-        'include-tags': core_1.Flags.string({
-            aliases: ['include-tags'],
-            default: [],
-            description: 'Only flows which have these tags will be included in the run',
-            multiple: true,
-            parse: (input) => input.split(','),
-        }),
-        'ios-device': core_1.Flags.string({
-            description: '[iOS only] iOS device to run your flow against',
-            options: [
-                'iphone-12',
-                'iphone-12-mini',
-                'iphone-12-pro-max',
-                'iphone-13',
-                'iphone-13-mini',
-                'iphone-13-pro-max',
-                'iphone-14',
-                'iphone-14-plus',
-                'iphone-14-pro',
-                'iphone-14-pro-max',
-                'iphone-15',
-                'iphone-15-plus',
-                'iphone-15-pro',
-                'iphone-15-pro-max',
-                'ipad-pro-6th-gen',
-            ],
-        }),
-        'ios-version': core_1.Flags.string({
-            description: '[iOS only] iOS version to run your flow against',
-            options: ['15', '16', '17'],
-        }),
-        name: core_1.Flags.string({
-            description: 'A custom name for your upload (useful for tagging commits etc)',
-        }),
-        orientation: core_1.Flags.string({
-            description: '[Android only] The orientation of the device to run your flow against in degrees',
-            options: ['0', '90', '180', '270'],
-        }),
-    };
+    static flags = constants_1.flags;
     async run() {
         try {
-            const { args, flags } = await this.parse(Cloud);
+            const { args, flags, raw } = await this.parse(Cloud);
             const { 'android-api-level': androidApiLevel, 'android-device': androidDevice, apiKey, apiUrl, 'app-binary-id': appBinaryId, 'app-file': appFile, arm64, async, env, 'exclude-tags': excludeTags, flows, 'google-play': googlePlay, 'include-tags': includeTags, 'ios-device': iOSDevice, 'ios-version': iOSVersion, name, orientation, ...rest } = flags;
             if (arm64) {
                 (0, cli_ux_1.info)('Contact hello@devicecloud.dev to enquire about arm64 devices');
@@ -241,46 +71,29 @@ class Cloud extends core_1.Command {
                 throw new Error('You must provide a flow file');
             }
             if (iOSVersion) {
-                const iOSCompatibilityLookup = {
-                    'ipad-pro-6th-gen': ['16', '17'],
-                    'iphone-12': ['15', '16', '17'],
-                    'iphone-12-mini': ['15', '16', '17'],
-                    'iphone-12-pro-max': ['15', '16', '17'],
-                    'iphone-13': ['15', '16', '17'],
-                    'iphone-13-mini': ['15', '16', '17'],
-                    'iphone-13-pro-max': ['15', '16', '17'],
-                    'iphone-14': ['16', '17'],
-                    'iphone-14-plus': ['16', '17'],
-                    'iphone-14-pro': ['16', '17'],
-                    'iphone-14-pro-max': ['16', '17'],
-                    'iphone-15': ['17'],
-                    'iphone-15-plus': ['17'],
-                    'iphone-15-pro': ['17'],
-                    'iphone-15-pro-max': ['17'],
-                };
                 const iOSDeviceID = iOSDevice || 'iphone-14';
-                const supportediOSVersions = iOSCompatibilityLookup[iOSDeviceID];
+                const supportediOSVersions = constants_1.iOSCompatibilityLookup[iOSDeviceID];
                 if (!supportediOSVersions.includes(iOSVersion)) {
                     throw new Error(`${iOSDeviceID} only supports these iOS versions: ${supportediOSVersions.join(',')}`);
                 }
             }
-            let testFileNames = [];
-            let continueOnFailure = true;
-            let sequentialFlows = [];
+            flowFile = path.resolve(flowFile);
             if (!flowFile?.endsWith('.yaml') &&
                 !flowFile?.endsWith('.yml') &&
                 !flowFile?.endsWith('/')) {
                 flowFile += '/';
             }
+            let executionPlan;
             try {
-                const executionPlan = await (0, plan_1.plan)(flowFile, includeTags.flat(), excludeTags.flat());
-                testFileNames = executionPlan.flowsToRun;
-                continueOnFailure = executionPlan.sequence?.continueOnFailure ?? true;
-                sequentialFlows = executionPlan.sequence?.flows ?? [];
+                executionPlan = await (0, plan_1.plan)(flowFile, includeTags.flat(), excludeTags.flat());
             }
             catch (error) {
                 console.error(error);
+                // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+                process.exit(2);
             }
+            const { allExcludeTags, allIncludeTags, flowsToRun: testFileNames, referencedFiles, sequence, } = executionPlan;
+            const { continueOnFailure = true, flows: sequentialFlows = [] } = sequence ?? {};
             if (!appBinaryId) {
                 if (!(flowFile && finalAppFile)) {
                     throw new Error('You must provide a flow file and an app binary id');
@@ -288,6 +101,9 @@ class Cloud extends core_1.Command {
                 if (!finalAppFile.endsWith('.apk') && !finalAppFile.endsWith('.zip')) {
                     throw new Error('App file must be a .apk or .zip file');
                 }
+                if (finalAppFile.endsWith('.zip')) {
+                    await (0, methods_1.verifyAppZip)(finalAppFile);
+                }
             }
             const flagLogs = [];
             for (const [k, v] of Object.entries(flags)) {
@@ -297,15 +113,15 @@ class Cloud extends core_1.Command {
             }
             this.log(`
 
-      Submitting new job
-    → Flow(s): ${flowFile}
-    → App: ${appBinaryId || finalAppFile}
+        Submitting new job
+      → Flow(s): ${flowFile}
+      → App: ${appBinaryId || finalAppFile}
 
-      With options
-    → ${flagLogs.join(`
-    → `)}
+        With options
+      → ${flagLogs.join(`
+      → `)}
 
-    `);
+      `);
             if (!finalBinaryId) {
                 core_1.ux.action.start('Uploading binary', 'Initializing', { stdout: true });
                 const binaryFormData = new FormData();
@@ -318,7 +134,7 @@ class Cloud extends core_1.Command {
                     headers: { 'x-app-api-key': apiKey },
                 };
                 core_1.ux.action.status = `Uploading`;
-                const { binaryId, message } = await typeSafePost(apiUrl, '/uploads/binary', options);
+                const { binaryId, message } = await (0, methods_1.typeSafePost)(apiUrl, '/uploads/binary', options);
                 if (!binaryId)
                     throw new Error(message);
                 core_1.ux.action.stop(`\nBinary uploaded with id: ${binaryId}`);
@@ -331,14 +147,15 @@ class Cloud extends core_1.Command {
                 acc[key] = value;
                 return acc;
             }, {});
-            const path = flowFile.split('/').slice(0, -1).join('/');
-            const buffer = await compressDir(path?.length ? path : './');
-            // const buffer =
-            //   totalFlowFiles > 1 || flowFile?.endsWith('/')
-            //     ? await compressDir(
-            //         flowFile!.split('/').slice(0, -1).join('/') ?? '.',
-            //       )
-            //     : await compressFile(flowFile!);
+            const buffer = await (0, methods_1.compressFilesFromRelativePath)(flowFile?.endsWith('.yaml') || flowFile?.endsWith('.yml')
+                ? path.dirname(flowFile)
+                : flowFile, [
+                ...new Set([
+                    ...referencedFiles,
+                    ...testFileNames,
+                    ...sequentialFlows,
+                ]),
+            ]);
             const blob = new Blob([buffer], {
                 type: mimeTypeLookupByExtension.zip,
             });
@@ -348,22 +165,23 @@ class Cloud extends core_1.Command {
             testFormData.set('sequentialFlows', JSON.stringify(sequentialFlows));
             testFormData.set('env', JSON.stringify(envObject));
             testFormData.set('googlePlay', googlePlay ? 'true' : 'false');
-            testFormData.set('config', JSON.stringify({ continueOnFailure, orientation }));
-            if (androidApiLevel) {
+            testFormData.set('config', JSON.stringify({
+                allExcludeTags,
+                allIncludeTags,
+                continueOnFailure,
+                orientation,
+                raw,
+            }));
+            if (androidApiLevel)
                 testFormData.set('androidApiLevel', androidApiLevel.toString());
-            }
-            if (androidDevice) {
+            if (androidDevice)
                 testFormData.set('androidDevice', androidDevice.toString());
-            }
-            if (iOSVersion) {
+            if (iOSVersion)
                 testFormData.set('iOSVersion', iOSVersion.toString());
-            }
-            if (iOSDevice) {
+            if (iOSDevice)
                 testFormData.set('iOSDevice', iOSDevice.toString());
-            }
-            if (name) {
+            if (name)
                 testFormData.set('name', name.toString());
-            }
             for (const [key, value] of Object.entries(rest)) {
                 if (value) {
                     testFormData.set(key, value);
@@ -373,7 +191,7 @@ class Cloud extends core_1.Command {
                 body: testFormData,
                 headers: { 'x-app-api-key': apiKey },
             };
-            const { message, results } = await typeSafePost(apiUrl, '/uploads/flow', options);
+            const { message, results } = await (0, methods_1.typeSafePost)(apiUrl, '/uploads/flow', options);
             if (!results?.length)
                 (0, errors_1.error)('No tests created: ' + message);
             (0, cli_ux_1.info)(`\nCreated ${results.length} tests: ${results
@@ -390,7 +208,7 @@ class Cloud extends core_1.Command {
             core_1.ux.action.start('Waiting for results', 'Initializing', { stdout: true });
             (0, cli_ux_1.info)('\nYou can safely close this terminal and the tests will continue\n');
             const intervalId = setInterval(async () => {
-                const { results: updatedResults } = await typeSafeGet(apiUrl, `/results/${results[0].test_upload_id}`, {
+                const { results: updatedResults } = await (0, methods_1.typeSafeGet)(apiUrl, `/results/${results[0].test_upload_id}`, {
                     headers: { 'x-app-api-key': apiKey },
                 });
                 if (!updatedResults) {
@@ -411,7 +229,8 @@ class Cloud extends core_1.Command {
                     (0, cli_ux_1.info)('\n');
                     clearInterval(intervalId);
                     if (updatedResults.some((result) => result.status === 'FAILED')) {
-                        (0, cli_ux_1.exit)(1);
+                        // eslint-disable-next-line no-process-exit, unicorn/no-process-exit
+                        process.exit(2);
                     }
                 }
             }, 5000);

package/dist/constants.d.ts

@@ -0,0 +1,23 @@
+import { EiOSDevices } from './commands/cloud';
+export declare const flags: {
+    'android-api-level': import("@oclif/core/lib/interfaces").OptionFlag<number | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'android-device': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    apiKey: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    apiUrl: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'app-binary-id': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'app-file': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    arm64: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    async: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    env: import("@oclif/core/lib/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'exclude-tags': import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+    flows: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'google-play': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    'include-tags': import("@oclif/core/lib/interfaces").OptionFlag<string[], import("@oclif/core/lib/interfaces").CustomOptions>;
+    'ios-device': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    'ios-version': import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    name: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+    orientation: import("@oclif/core/lib/interfaces").OptionFlag<string | undefined, import("@oclif/core/lib/interfaces").CustomOptions>;
+};
+export declare const iOSCompatibilityLookup: {
+    [k in EiOSDevices]: string[];
+};

package/dist/constants.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.iOSCompatibilityLookup = exports.flags = void 0;
+const core_1 = require("@oclif/core");
+exports.flags = {
+    'android-api-level': core_1.Flags.integer({
+        description: '[Android only] Android API level to run your flow against',
+        options: ['32', '33', '34'],
+    }),
+    'android-device': core_1.Flags.string({
+        description: '[Android only] Android device to run your flow against',
+        options: [
+            'pixel-6',
+            'pixel-6a',
+            'pixel-6-pro',
+            'pixel-7',
+            'pixel-7-pro',
+            'generic-tablet',
+        ],
+    }),
+    apiKey: core_1.Flags.string({
+        aliases: ['api-key'],
+        description: 'API key',
+    }),
+    apiUrl: core_1.Flags.string({
+        aliases: ['api-url', 'apiURL'],
+        default: 'https://api.devicecloud.dev',
+        description: 'API base URL',
+        hidden: true,
+    }),
+    'app-binary-id': core_1.Flags.string({
+        aliases: ['app-binary-id'],
+        description: 'The ID of the app binary previously uploaded to Maestro Cloud',
+    }),
+    'app-file': core_1.Flags.file({
+        aliases: ['app-file'],
+        description: 'App binary to run your flows against',
+    }),
+    arm64: core_1.Flags.boolean({
+        default: false,
+        description: '[Android only] Run your flow against arm64 devices',
+    }),
+    async: core_1.Flags.boolean({
+        description: 'Wait for the results of the run',
+    }),
+    env: core_1.Flags.file({
+        char: 'e',
+        description: 'One or more environment variables to inject into your flows',
+        multiple: true,
+    }),
+    'exclude-tags': core_1.Flags.string({
+        aliases: ['exclude-tags'],
+        default: [],
+        description: 'Flows which have these tags will be excluded from the run',
+        multiple: true,
+        parse: (input) => input.split(','),
+    }),
+    flows: core_1.Flags.string({
+        description: 'The path to the flow file or folder containing your flows',
+    }),
+    'google-play': core_1.Flags.boolean({
+        aliases: ['google-play'],
+        default: false,
+        description: '[Android only] Run your flow against Google Play devices',
+    }),
+    'include-tags': core_1.Flags.string({
+        aliases: ['include-tags'],
+        default: [],
+        description: 'Only flows which have these tags will be included in the run',
+        multiple: true,
+        parse: (input) => input.split(','),
+    }),
+    'ios-device': core_1.Flags.string({
+        description: '[iOS only] iOS device to run your flow against',
+        options: [
+            'iphone-12',
+            'iphone-12-mini',
+            'iphone-12-pro-max',
+            'iphone-13',
+            'iphone-13-mini',
+            'iphone-13-pro-max',
+            'iphone-14',
+            'iphone-14-plus',
+            'iphone-14-pro',
+            'iphone-14-pro-max',
+            'iphone-15',
+            'iphone-15-plus',
+            'iphone-15-pro',
+            'iphone-15-pro-max',
+            'ipad-pro-6th-gen',
+        ],
+    }),
+    'ios-version': core_1.Flags.string({
+        description: '[iOS only] iOS version to run your flow against',
+        options: ['15', '16', '17'],
+    }),
+    name: core_1.Flags.string({
+        description: 'A custom name for your upload (useful for tagging commits etc)',
+    }),
+    orientation: core_1.Flags.string({
+        description: '[Android only] The orientation of the device to run your flow against in degrees',
+        options: ['0', '90', '180', '270'],
+    }),
+};
+exports.iOSCompatibilityLookup = {
+    'ipad-pro-6th-gen': ['16', '17'],
+    'iphone-12': ['15', '16', '17'],
+    'iphone-12-mini': ['15', '16', '17'],
+    'iphone-12-pro-max': ['15', '16', '17'],
+    'iphone-13': ['15', '16', '17'],
+    'iphone-13-mini': ['15', '16', '17'],
+    'iphone-13-pro-max': ['15', '16', '17'],
+    'iphone-14': ['16', '17'],
+    'iphone-14-plus': ['16', '17'],
+    'iphone-14-pro': ['16', '17'],
+    'iphone-14-pro-max': ['16', '17'],
+    'iphone-15': ['17'],
+    'iphone-15-plus': ['17'],
+    'iphone-15-pro': ['17'],
+    'iphone-15-pro-max': ['17'],
+};

package/dist/methods.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import * as archiver from 'archiver';
+import { paths } from '../../api/schema.types';
+export declare const typeSafePost: <T extends keyof paths>(baseUrl: string, path: string, init?: {
+    body?: FormData;
+    headers?: HeadersInit;
+}) => Promise<paths[T]["post"]["responses"]["201"]["content"]["application/json"]>;
+export declare const typeSafeGet: <T extends keyof paths>(baseUrl: string, path: string, init?: {
+    body?: FormData;
+    headers?: HeadersInit;
+}) => Promise<paths[T]["get"]["responses"]["200"]["content"]["application/json"]>;
+export declare const toBuffer: (archive: archiver.Archiver) => Promise<Buffer>;
+export declare const compressDir: (sourceDir: string) => Promise<Buffer>;
+export declare const compressFilesFromRelativePath: (path: string, files: string[]) => Promise<Buffer>;
+export declare const verifyAppZip: (zipPath: string) => Promise<void>;

package/dist/methods.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyAppZip = exports.compressFilesFromRelativePath = exports.compressDir = exports.toBuffer = exports.typeSafeGet = exports.typeSafePost = void 0;
+const archiver = require("archiver");
+// import { writeFile } from 'node:fs/promises';
+const nodePath = require("node:path");
+const node_stream_1 = require("node:stream");
+const StreamZip = require("node-stream-zip");
+const PERMITTED_EXTENSIONS = new Set([
+    'yml',
+    'yaml',
+    'png',
+    'jpg',
+    'jpeg',
+    'gif',
+    'mp4',
+    'js',
+]);
+const typeSafePost = async (baseUrl, path, init) => {
+    const res = await fetch(baseUrl + path, { ...init, method: 'POST' });
+    if (!res.ok) {
+        throw new Error(await res.text());
+    }
+    return res.json();
+};
+exports.typeSafePost = typeSafePost;
+const typeSafeGet = async (baseUrl, path, init) => {
+    const res = await fetch(baseUrl + path, init);
+    if (!res.ok) {
+        throw new Error(await res.text());
+    }
+    return res.json();
+};
+exports.typeSafeGet = typeSafeGet;
+const toBuffer = async (archive) => {
+    const chunks = [];
+    const writable = new node_stream_1.Writable();
+    writable._write = (chunk, _, callback) => {
+        // save to array to concatenate later
+        chunks.push(chunk);
+        callback();
+    };
+    // pipe to writable
+    archive.pipe(writable);
+    await archive.finalize();
+    // once done, concatenate chunks
+    return Buffer.concat(chunks);
+};
+exports.toBuffer = toBuffer;
+const compressDir = async (sourceDir) => {
+    // const output = createWriteStream(zipTargetPath);
+    const archive = archiver('zip', {
+        zlib: { level: 9 },
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    archive.directory(sourceDir, '.', (data) => {
+        if (data.name.split('/')[0] === 'node_modules')
+            return false;
+        if (PERMITTED_EXTENSIONS.has(data.name.split('.').pop())) {
+            return data;
+        }
+        return false;
+    });
+    const buffer = await (0, exports.toBuffer)(archive);
+    // await writeFile('./my-zip.zip', buffer);
+    return buffer;
+};
+exports.compressDir = compressDir;
+const compressFilesFromRelativePath = async (path, files) => {
+    const archive = archiver('zip', {
+        zlib: { level: 9 },
+    });
+    archive.on('error', (err) => {
+        throw err;
+    });
+    for (const file of files) {
+        archive.file(nodePath.resolve(path, file), { name: file });
+    }
+    const buffer = await (0, exports.toBuffer)(archive);
+    // await writeFile('./my-zip.zip', buffer);
+    return buffer;
+};
+exports.compressFilesFromRelativePath = compressFilesFromRelativePath;
+const verifyAppZip = async (zipPath) => {
+    // eslint-disable-next-line import/namespace, new-cap
+    const zip = await new StreamZip.async({
+        file: zipPath,
+        storeEntries: true,
+    });
+    const entries = await zip.entries();
+    const topLevelEntries = Object.values(entries).filter((entry) => !entry.name.split('/')[1]);
+    if (topLevelEntries.length !== 1 ||
+        !topLevelEntries[0].name.endsWith('.app/')) {
+        throw new Error('Zip file must contain exactly one entry which is a .app, check the contents of the zip file');
+    }
+    zip.close();
+};
+exports.verifyAppZip = verifyAppZip;

package/dist/plan.d.ts

@@ -1,5 +1,8 @@
 interface IExecutionPlan {
+    allExcludeTags?: null | string[];
+    allIncludeTags?: null | string[];
     flowsToRun: string[];
+    referencedFiles: string[];
     sequence?: IFlowSequence | null;
     totalFlowFiles: number;
 }

package/dist/plan.js

@@ -1,76 +1,43 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.plan = void 0;
-const globToRegExp = require("glob-to-regexp");
-const yaml = require("js-yaml");
+/* eslint-disable complexity */
+const glob_1 = require("glob");
 const fs = require("node:fs");
 const path = require("node:path");
-function getFlowsToRunInSequence(paths, flowOrder) {
-    if (flowOrder.length === 0)
-        return [];
-    const orderSet = new Set(flowOrder);
-    const namesInOrder = Object.keys(paths).filter((key) => orderSet.has(key));
-    if (namesInOrder.length === 0)
-        return [];
-    const result = [...orderSet].filter((item) => namesInOrder.includes(item));
-    if (result.length === 0) {
-        throw new Error(`Could not find flows needed for execution in order: ${[...orderSet]
-            .filter((item) => !namesInOrder.includes(item))
-            .join(', ')}`);
-    }
-    else if (flowOrder
-        .slice(0, result.length)
-        .every((value, index) => value === result[index])) {
-        return result.map((item) => paths[item]);
-    }
-    else {
-        return [];
-    }
-}
-function isFlowFile(filePath) {
-    return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
-}
-const readYamlFileAsJson = (filePath) => {
-    const yamlText = fs.readFileSync(filePath, 'utf8');
-    return yaml.load(yamlText);
-};
-const readConfigFromYamlFileAsJson = (filePath) => {
-    const yamlText = fs.readFileSync(filePath, 'utf8');
-    if (yamlText.includes('\n---\n')) {
-        const yamlTexts = yamlText.split('\n---\n');
-        const config = yaml.load(yamlTexts[0]);
-        if (Object.keys(config).length > 0) {
-            return config;
-        }
-    }
-    return null;
-};
-async function walk(dir, filterFunction) {
-    const readDirResult = await fs.promises.readdir(dir);
-    const files = await Promise.all(readDirResult.map(async (file) => {
-        const filePath = path.join(dir, file);
-        const stats = await fs.promises.stat(filePath);
-        if (stats.isDirectory())
-            return walk(filePath);
-        if (stats.isFile())
-            if (filterFunction) {
-                if (filterFunction(filePath))
-                    return filePath;
-            }
-            else {
-                return filePath;
-            }
-    }));
-    return files.flat().filter(Boolean);
-}
+const planMethods_1 = require("./planMethods");
+const commandsThatRequireFiles = new Set(['addMedia', 'runFlow', 'runScript']);
 async function plan(input, includeTags, excludeTags) {
     if (!fs.existsSync(input)) {
         throw new Error(`Flow path does not exist: ${path.resolve(input)}`);
     }
     if (fs.lstatSync(input).isFile()) {
-        return { flowsToRun: [input.split('/').pop() ?? input], totalFlowFiles: 1 };
+        const directory = path.dirname(input);
+        const { testSteps } = (0, planMethods_1.readTestYamlFileAsJson)(input);
+        let errors = [];
+        let allFiles = [];
+        for (const command of testSteps) {
+            if (typeof command === 'string')
+                continue;
+            for (const [commandName, commandValue] of Object.entries(command)) {
+                if (commandsThatRequireFiles.has(commandName)) {
+                    const { errors: newErrors, files } = (0, planMethods_1.checkIfFilesExistInWorkspace)(commandName, commandValue, path.normalize(input), directory + '/');
+                    errors = [...errors, ...newErrors];
+                    allFiles = [...allFiles, ...files];
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new Error('The following flow files are not present in the provided directory: \n' +
+                errors.join('\n'));
+        }
+        return {
+            flowsToRun: [input.split('/').pop() ?? input],
+            referencedFiles: [...new Set(allFiles)],
+            totalFlowFiles: 1,
+        };
     }
-    let unfilteredFlowFiles = await walk(input, isFlowFile);
+    let unfilteredFlowFiles = await (0, planMethods_1.walk)(input, planMethods_1.isFlowFile);
     if (unfilteredFlowFiles.length === 0) {
         throw new Error(`Flow directory does not contain any Flow files: ${path.resolve(input)}`);
     }
@@ -81,12 +48,17 @@ async function plan(input, includeTags, excludeTags) {
     const relativeFilePaths = unfilteredFlowFiles.map((file) => file.replace(cleanPath, ''));
     const topLevelFlowFiles = relativeFilePaths.filter((file) => !file.includes('/'));
     const workspaceConfig = configFilePath
-        ? readYamlFileAsJson(configFilePath)
+        ? (0, planMethods_1.readYamlFileAsJson)(configFilePath)
         : {};
     let unsortedFlowFiles = topLevelFlowFiles;
     if (workspaceConfig.flows) {
-        const matchers = workspaceConfig.flows.map((glob) => glob === '*' ? /^((?!\/).)*$/ : globToRegExp(glob));
-        unsortedFlowFiles = relativeFilePaths.filter((filePath) => matchers.some((matcher) => matcher.test(filePath)));
+        const globs = workspaceConfig.flows.map((glob) => glob);
+        const matchedFiles = await (0, glob_1.glob)(globs, {
+            cwd: input,
+            nodir: true,
+        });
+        unsortedFlowFiles = matchedFiles.filter((file) => file !== 'config.yaml' &&
+            (file.endsWith('.yaml') || file.endsWith('.yml')));
     }
     if (unsortedFlowFiles.length === 0) {
         const error = workspaceConfig.flows
@@ -95,10 +67,42 @@ async function plan(input, includeTags, excludeTags) {
         throw error;
     }
     // eslint-disable-next-line unicorn/no-array-reduce
-    const configPerFlowFile = unsortedFlowFiles.reduce((acc, filePath) => {
-        acc[filePath] = readConfigFromYamlFileAsJson(cleanPath + filePath);
+    const { configPerFlowFile } = unsortedFlowFiles.reduce((acc, filePath) => {
+        const { config } = (0, planMethods_1.readTestYamlFileAsJson)(cleanPath + filePath);
+        acc.configPerFlowFile[filePath] = config;
         return acc;
-    }, {});
+    }, {
+        configPerFlowFile: {},
+    });
+    // eslint-disable-next-line unicorn/no-array-reduce
+    const { testStepsPerFlowFile } = unfilteredFlowFiles.reduce((acc, filePath) => {
+        const { testSteps } = (0, planMethods_1.readTestYamlFileAsJson)(filePath);
+        acc.testStepsPerFlowFile[filePath] = testSteps;
+        return acc;
+    }, {
+        testStepsPerFlowFile: {},
+    });
+    let errors = [];
+    let allFiles = [];
+    for (const [filePath, commands] of Object.entries(testStepsPerFlowFile)) {
+        if (!commands)
+            break;
+        for (const command of commands) {
+            if (typeof command === 'string')
+                continue;
+            for (const [commandName, commandValue] of Object.entries(command)) {
+                if (commandsThatRequireFiles.has(commandName)) {
+                    const { errors: newErrors, files } = (0, planMethods_1.checkIfFilesExistInWorkspace)(commandName, commandValue, filePath, cleanPath);
+                    errors = [...errors, ...newErrors];
+                    allFiles = [...allFiles, ...files];
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error('The following flow files are not present in the provided directory: \n' +
+            errors.join('\n'));
+    }
     const allIncludeTags = [
         ...includeTags,
         ...(workspaceConfig.includeTags || []),
@@ -125,7 +129,7 @@ async function plan(input, includeTags, excludeTags) {
         return acc;
     }, {});
     const flowsToRunInSequence = workspaceConfig.executionOrder?.flowsOrder
-        ?.map((flowOrder) => getFlowsToRunInSequence(pathsByName, [flowOrder]))
+        ?.map((flowOrder) => (0, planMethods_1.getFlowsToRunInSequence)(pathsByName, [flowOrder]))
         .flat() || [];
     const normalFlows = allFlows.filter((flow) => !flowsToRunInSequence.includes(flow));
     // for (const filePath of allFlows) {
@@ -142,7 +146,10 @@ async function plan(input, includeTags, excludeTags) {
     //   );
     // }
     return {
+        allExcludeTags,
+        allIncludeTags,
         flowsToRun: normalFlows,
+        referencedFiles: [...new Set(allFiles)],
         sequence: {
             continueOnFailure: workspaceConfig.executionOrder?.continueOnFailure,
             flows: flowsToRunInSequence,

package/dist/planMethods.d.ts

@@ -0,0 +1,17 @@
+export declare function getFlowsToRunInSequence(paths: {
+    [key: string]: string;
+}, flowOrder: string[]): string[];
+export declare function isFlowFile(filePath: string): boolean;
+export declare const readYamlFileAsJson: (filePath: string) => unknown;
+export declare const readTestYamlFileAsJson: (filePath: string) => {
+    config: Record<string, unknown>;
+    testSteps: Record<string, unknown>[];
+} | {
+    config: null;
+    testSteps: Record<string, unknown>[];
+};
+export declare function walk(dir: string, filterFunction?: (filePath: string) => boolean): Promise<string[]>;
+export declare const checkIfFilesExistInWorkspace: (commandName: string, command: Record<string, string> | string | string[], filePath: string, cleanPath: string) => {
+    errors: string[];
+    files: string[];
+};

package/dist/planMethods.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkIfFilesExistInWorkspace = exports.walk = exports.readTestYamlFileAsJson = exports.readYamlFileAsJson = exports.isFlowFile = exports.getFlowsToRunInSequence = void 0;
+/* eslint-disable unicorn/filename-case */
+const yaml = require("js-yaml");
+const fs = require("node:fs");
+const path = require("node:path");
+function getFlowsToRunInSequence(paths, flowOrder) {
+    if (flowOrder.length === 0)
+        return [];
+    const orderSet = new Set(flowOrder);
+    const namesInOrder = Object.keys(paths).filter((key) => orderSet.has(key));
+    if (namesInOrder.length === 0)
+        return [];
+    const result = [...orderSet].filter((item) => namesInOrder.includes(item));
+    if (result.length === 0) {
+        throw new Error(`Could not find flows needed for execution in order: ${[...orderSet]
+            .filter((item) => !namesInOrder.includes(item))
+            .join(', ')}`);
+    }
+    else if (flowOrder
+        .slice(0, result.length)
+        .every((value, index) => value === result[index])) {
+        return result.map((item) => paths[item]);
+    }
+    else {
+        return [];
+    }
+}
+exports.getFlowsToRunInSequence = getFlowsToRunInSequence;
+function isFlowFile(filePath) {
+    return filePath.endsWith('.yaml') || filePath.endsWith('.yml');
+}
+exports.isFlowFile = isFlowFile;
+const readYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    return yaml.load(yamlText);
+};
+exports.readYamlFileAsJson = readYamlFileAsJson;
+const readTestYamlFileAsJson = (filePath) => {
+    const yamlText = fs.readFileSync(filePath, 'utf8');
+    if (yamlText.includes('\n---\n')) {
+        const yamlTexts = yamlText.split('\n---\n');
+        const config = yaml.load(yamlTexts[0]);
+        const testSteps = yaml.load(yamlTexts[1]);
+        if (Object.keys(config ?? {}).length > 0) {
+            return { config, testSteps };
+        }
+    }
+    const testSteps = yaml.load(yamlText);
+    if (Object.keys(testSteps).length > 0) {
+        return { config: null, testSteps };
+    }
+    return { config: null, testSteps };
+};
+exports.readTestYamlFileAsJson = readTestYamlFileAsJson;
+async function walk(dir, filterFunction) {
+    const readDirResult = await fs.promises.readdir(dir);
+    const files = await Promise.all(readDirResult.map(async (file) => {
+        const filePath = path.join(dir, file);
+        const stats = await fs.promises.stat(filePath);
+        if (stats.isDirectory())
+            return walk(filePath, filterFunction);
+        if (stats.isFile())
+            if (filterFunction) {
+                if (filterFunction(filePath))
+                    return filePath;
+            }
+            else {
+                return filePath;
+            }
+    }));
+    return files.flat().filter(Boolean);
+}
+exports.walk = walk;
+const checkIfFilesExistInWorkspace = (commandName, command, filePath, cleanPath) => {
+    const errors = [];
+    const files = [];
+    const directory = path.dirname(filePath);
+    const buildError = (error) => `Flow file "${filePath}" has a command "${commandName}" that references a ${error} "${command}"`;
+    const processFilePath = (relativePath) => {
+        const absoluteFilePath = path.resolve(directory, relativePath);
+        const error = checkFile(absoluteFilePath, cleanPath);
+        if (error)
+            errors.push(buildError(error));
+        files.push(absoluteFilePath.replace(cleanPath, './'));
+    };
+    // simple command
+    if (typeof command === 'string')
+        processFilePath(command);
+    // array command
+    if (Array.isArray(command)) {
+        for (const file of command) {
+            processFilePath(file);
+        }
+    }
+    // object command
+    const x = command; // prevent annoying ts error
+    if (typeof command === 'object' && x?.file)
+        processFilePath(x.file);
+    return { errors, files };
+};
+exports.checkIfFilesExistInWorkspace = checkIfFilesExistInWorkspace;
+const checkFile = (filePath, cleanPath) => {
+    if (!fs.existsSync(filePath))
+        return `non-existent file`;
+    if (!filePath.startsWith(cleanPath))
+        return `file outside the workspace`;
+};

package/oclif.manifest.json

@@ -220,5 +220,5 @@
       ]
     }
   },
-  "version": "0.0.2"
+  "version": "0.0.4"
 }

package/package.json

@@ -12,8 +12,9 @@
     "@oclif/plugin-update": "^4.1.11",
     "@oclif/plugin-warn-if-update-available": "^3.0.10",
     "archiver": "^6.0.1",
-    "glob-to-regexp": "^0.4.1",
-    "js-yaml": "^4.1.0"
+    "glob": "^10.3.10",
+    "js-yaml": "^4.1.0",
+    "node-stream-zip": "^1.15.0"
   },
   "description": "Better cloud maestro testing",
   "devDependencies": {
@@ -72,9 +73,9 @@
     "test": "mocha --forbid-only \"test/**/*.test.ts\"",
     "version": "oclif readme && git add README.md"
   },
-  "version": "0.0.2",
+  "version": "0.0.4",
   "bugs": {
-    "url": "https://discord.gg/GzZBHcUJ"
+    "url": "https://discord.gg/gm3mJwcNw8"
   },
   "keywords": [
     "devicecloud",