@devicecloud.dev/dcd 3.7.11 → 4.0.0

package/dist/gateways/{ApiGateway.js → api-gateway.js}

@@ -1,55 +1,44 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiGateway = void 0;
-class ApiGateway {
-    static getResultsForUpload = async (baseUrl, apiKey, uploadId) => {
-        // todo: merge with getUploadStatus
-        const res = await fetch(`${baseUrl}/results/${uploadId}`, {
-            headers: { 'x-app-api-key': apiKey },
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        return res.json();
-    };
-    static getUploadStatus = async (baseUrl, apiKey, options) => {
-        const queryParams = new URLSearchParams();
-        if (options.uploadId) {
-            queryParams.append('uploadId', options.uploadId);
-        }
-        if (options.name) {
-            queryParams.append('name', options.name);
-        }
-        const response = await fetch(`${baseUrl}/uploads/status?${queryParams}`, {
+exports.ApiGateway = {
+    async checkForExistingUpload(baseUrl, apiKey, sha) {
+        const res = await fetch(`${baseUrl}/uploads/checkForExistingUpload`, {
+            body: JSON.stringify({ sha }),
             headers: {
+                'content-type': 'application/json',
                 'x-app-api-key': apiKey,
             },
+            method: 'POST',
         });
-        if (!response.ok) {
-            throw new Error(`Failed to fetch status: ${response.statusText}`);
-        }
-        return response.json();
-    };
-    static downloadArtifactsZip = async (baseUrl, apiKey, uploadId, results, artifactsPath = './artifacts.zip') => {
+        return res.json();
+    },
+    async downloadArtifactsZip(baseUrl, apiKey, uploadId, results, artifactsPath = './artifacts.zip') {
         const res = await fetch(`${baseUrl}/results/${uploadId}/download`, {
-            method: 'POST',
+            body: JSON.stringify({ results }),
             headers: {
-                'x-app-api-key': apiKey,
                 'content-type': 'application/json',
+                'x-app-api-key': apiKey,
             },
-            body: JSON.stringify({ results }),
+            method: 'POST',
         });
         if (!res.ok) {
             throw new Error(await res.text());
         }
         // Handle tilde expansion for home directory
         if (artifactsPath.startsWith('~/') || artifactsPath === '~') {
-            artifactsPath = artifactsPath.replace(/^~(?=$|\/|\\)/, require('os').homedir());
+            artifactsPath = artifactsPath.replace(/^~(?=$|\/|\\)/, 
+            // eslint-disable-next-line unicorn/prefer-module
+            require('node:os').homedir());
         }
         // Create directory structure if it doesn't exist
+        // eslint-disable-next-line unicorn/prefer-module
         const { dirname } = require('node:path');
-        const { mkdirSync, createWriteStream } = require('node:fs');
+        // eslint-disable-next-line unicorn/prefer-module
+        const { createWriteStream, mkdirSync } = require('node:fs');
+        // eslint-disable-next-line unicorn/prefer-module
         const { finished } = require('node:stream/promises');
+        // eslint-disable-next-line unicorn/prefer-module
         const { Readable } = require('node:stream');
         const directory = dirname(artifactsPath);
         if (directory !== '.') {
@@ -64,60 +53,76 @@ class ApiGateway {
             }
         }
         const fileStream = createWriteStream(artifactsPath, { flags: 'wx' });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         await finished(Readable.fromWeb(res.body).pipe(fileStream));
-    };
-    static uploadFlow = async (baseUrl, apiKey, testFormData) => {
-        const res = await fetch(`${baseUrl}/uploads/flow`, {
-            method: 'POST',
-            body: testFormData,
-            headers: {
-                'x-app-api-key': apiKey,
-            },
-        });
-        if (!res.ok) {
-            throw new Error(await res.text());
-        }
-        return res.json();
-    };
-    static finaliseUpload = async (baseUrl, apiKey, id, metadata, path, sha) => {
+    },
+    // eslint-disable-next-line max-params
+    async finaliseUpload(baseUrl, apiKey, id, metadata, path, sha) {
         const res = await fetch(`${baseUrl}/uploads/finaliseUpload`, {
-            method: 'POST',
             body: JSON.stringify({ id, metadata, path, sha }),
             headers: {
                 'content-type': 'application/json',
                 'x-app-api-key': apiKey,
             },
+            method: 'POST',
         });
         if (!res.ok) {
             throw new Error(await res.text());
         }
         return res.json();
-    };
-    static getBinaryUploadUrl = async (baseUrl, apiKey, platform) => {
+    },
+    async getBinaryUploadUrl(baseUrl, apiKey, platform) {
         const res = await fetch(`${baseUrl}/uploads/getBinaryUploadUrl`, {
-            method: 'POST',
             body: JSON.stringify({ platform }),
             headers: {
                 'content-type': 'application/json',
                 'x-app-api-key': apiKey,
             },
+            method: 'POST',
         });
         if (!res.ok) {
             throw new Error(await res.text());
         }
         return res.json();
-    };
-    static checkForExistingUpload = async (baseUrl, apiKey, sha) => {
-        const res = await fetch(`${baseUrl}/uploads/checkForExistingUpload`, {
-            method: 'POST',
-            body: JSON.stringify({ sha }),
+    },
+    async getResultsForUpload(baseUrl, apiKey, uploadId) {
+        // TODO: merge with getUploadStatus
+        const res = await fetch(`${baseUrl}/results/${uploadId}`, {
+            headers: { 'x-app-api-key': apiKey },
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
+        return res.json();
+    },
+    async getUploadStatus(baseUrl, apiKey, options) {
+        const queryParams = new URLSearchParams();
+        if (options.uploadId) {
+            queryParams.append('uploadId', options.uploadId);
+        }
+        if (options.name) {
+            queryParams.append('name', options.name);
+        }
+        const response = await fetch(`${baseUrl}/uploads/status?${queryParams}`, {
             headers: {
-                'content-type': 'application/json',
                 'x-app-api-key': apiKey,
             },
         });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch status: ${response.statusText}`);
+        }
+        return response.json();
+    },
+    async uploadFlow(baseUrl, apiKey, testFormData) {
+        const res = await fetch(`${baseUrl}/uploads/flow`, {
+            body: testFormData,
+            headers: {
+                'x-app-api-key': apiKey,
+            },
+            method: 'POST',
+        });
+        if (!res.ok) {
+            throw new Error(await res.text());
+        }
         return res.json();
-    };
-}
-exports.ApiGateway = ApiGateway;
+    },
+};

package/dist/gateways/{SupabaseGateway.d.ts → supabase-gateway.d.ts}

@@ -1,11 +1,11 @@
 export declare class SupabaseGateway {
     private static SB;
-    static getSupabaseKeys(env: 'prod' | 'dev'): {
+    static getSupabaseKeys(env: 'dev' | 'prod'): {
         SUPABASE_PUBLIC_KEY: string;
         SUPABASE_URL: string;
     } | {
         SUPABASE_PUBLIC_KEY: string;
         SUPABASE_URL: string;
     };
-    static uploadToSignedUrl(env: 'prod' | 'dev', path: string, token: string, file: File): Promise<void>;
+    static uploadToSignedUrl(env: 'dev' | 'prod', path: string, token: string, file: File): Promise<void>;
 }

package/dist/gateways/{SupabaseGateway.js → supabase-gateway.js}

@@ -10,20 +10,23 @@ class SupabaseGateway {
         },
         prod: {
             SUPABASE_PUBLIC_KEY: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6InBneWRucGhiaW1ldGluc2dma2JvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3MDc1OTQzNDYsImV4cCI6MjAyMzE3MDM0Nn0.hAYOMFxxwX1exkQkY9xyQJGC_GhGnyogkj2N-kBkMI8',
-            SUPABASE_URL: 'https://pgydnphbimetinsgfkbo.supabase.co',
+            SUPABASE_URL: 'https://cloud.devicecloud.dev',
         },
     };
     static getSupabaseKeys(env) {
         return this.SB[env];
     }
     static async uploadToSignedUrl(env, path, token, file) {
-        const { SUPABASE_URL, SUPABASE_PUBLIC_KEY } = this.getSupabaseKeys(env);
+        const { SUPABASE_PUBLIC_KEY, SUPABASE_URL } = this.getSupabaseKeys(env);
         const supabase = (0, supabase_js_1.createClient)(SUPABASE_URL, SUPABASE_PUBLIC_KEY);
         const uploadToUrl = await supabase.storage
             .from('organizations')
             .uploadToSignedUrl(path, token, file);
-        if (uploadToUrl.error)
-            throw new Error(uploadToUrl.error);
+        if (uploadToUrl.error) {
+            const error = uploadToUrl.error;
+            const errorMessage = typeof error === 'string' ? error : error?.message || 'Upload failed';
+            throw new Error(errorMessage);
+        }
     }
 }
 exports.SupabaseGateway = SupabaseGateway;

package/dist/methods.d.ts

@@ -2,7 +2,7 @@ import * as archiver from 'archiver';
 import { TAppMetadata } from './types';
 export declare const toBuffer: (archive: archiver.Archiver) => Promise<Buffer<ArrayBuffer>>;
 export declare const compressFolderToBlob: (sourceDir: string) => Promise<Blob>;
-export declare const compressFilesFromRelativePath: (path: string, files: string[], commonRoot: string) => Promise<Buffer<ArrayBuffer>>;
+export declare const compressFilesFromRelativePath: (basePath: string, files: string[], commonRoot: string) => Promise<Buffer<ArrayBuffer>>;
 export declare const verifyAppZip: (zipPath: string) => Promise<void>;
 export declare const extractAppMetadataAndroid: (appFilePath: string) => Promise<TAppMetadata>;
 export declare const extractAppMetadataIosZip: (appFilePath: string) => Promise<TAppMetadata>;
@@ -17,7 +17,7 @@ export declare const verifyAdditionalAppFiles: (appFiles: string[] | undefined)
  * @param logger - Logger object with log and warn methods
  * @returns true if successful, false if an error occurred
  */
-export declare const writeJSONFile: (filePath: string, data: any, logger: {
+export declare const writeJSONFile: (filePath: string, data: unknown, logger: {
     log: (message: string) => void;
     warn: (message: string) => void;
 }) => void;

package/dist/methods.js

@@ -4,21 +4,19 @@ exports.formatDurationSeconds = exports.writeJSONFile = exports.verifyAdditional
 const core_1 = require("@oclif/core");
 // required polyfill for node 18
 const file_1 = require("@web-std/file");
-// @ts-ignore
 const AppInfoParser = require("app-info-parser");
 const archiver = require("archiver");
 const bplist_parser_1 = require("bplist-parser");
+const node_crypto_1 = require("node:crypto");
 const node_fs_1 = require("node:fs");
 const promises_1 = require("node:fs/promises");
-const nodePath = require("node:path");
+const path = require("node:path");
 const node_stream_1 = require("node:stream");
 const StreamZip = require("node-stream-zip");
 const plist_1 = require("plist");
-const node_crypto_1 = require("node:crypto");
-const path = require("path");
 const cloud_1 = require("./commands/cloud");
-const SupabaseGateway_1 = require("./gateways/SupabaseGateway");
-const ApiGateway_1 = require("./gateways/ApiGateway");
+const api_gateway_1 = require("./gateways/api-gateway");
+const supabase_gateway_1 = require("./gateways/supabase-gateway");
 const toBuffer = async (archive) => {
     const chunks = [];
     const writable = new node_stream_1.Writable();
@@ -46,7 +44,7 @@ const compressFolderToBlob = async (sourceDir) => {
     return new Blob([buffer], { type: 'application/zip' });
 };
 exports.compressFolderToBlob = compressFolderToBlob;
-const compressFilesFromRelativePath = async (path, files, commonRoot) => {
+const compressFilesFromRelativePath = async (basePath, files, commonRoot) => {
     const archive = archiver('zip', {
         zlib: { level: 9 },
     });
@@ -54,7 +52,7 @@ const compressFilesFromRelativePath = async (path, files, commonRoot) => {
         throw err;
     });
     for (const file of files) {
-        archive.file(nodePath.resolve(path, file), {
+        archive.file(path.resolve(basePath, file), {
             name: file.replace(commonRoot, ''),
         });
     }
@@ -148,23 +146,24 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
         file = new file_1.File([zippedAppBlob], filePath + '.zip');
     }
     else {
-        const binaryBlob = new Blob([await (0, promises_1.readFile)(filePath)], {
+        const fileBuffer = await (0, promises_1.readFile)(filePath);
+        const binaryBlob = new Blob([new Uint8Array(fileBuffer)], {
             type: cloud_1.mimeTypeLookupByExtension[filePath.split('.').pop()],
         });
         file = new file_1.File([binaryBlob], filePath);
     }
-    let sha = undefined;
+    let sha;
     try {
         sha = await getFileHashFromFile(file);
     }
-    catch (e) {
+    catch (error) {
         if (log) {
-            console.warn('Warning: Failed to get file hash', e);
+            console.warn('Warning: Failed to get file hash', error);
         }
     }
     if (!ignoreShaCheck && sha) {
         try {
-            const { appBinaryId, exists } = await ApiGateway_1.ApiGateway.checkForExistingUpload(apiUrl, apiKey, sha);
+            const { appBinaryId, exists } = await api_gateway_1.ApiGateway.checkForExistingUpload(apiUrl, apiKey, sha);
             if (exists) {
                 if (log) {
                     core_1.ux.info(`sha hash matches existing binary with id: ${appBinaryId}, skipping upload. Force upload with --ignore-sha-check`);
@@ -177,7 +176,7 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
             // ignore error
         }
     }
-    const { id, message, path, token } = await ApiGateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
+    const { id, message, path, token } = await api_gateway_1.ApiGateway.getBinaryUploadUrl(apiUrl, apiKey, filePath?.endsWith('.apk') ? 'android' : 'ios');
     if (!path)
         throw new Error(message);
     let metadata;
@@ -194,8 +193,8 @@ const uploadBinary = async (filePath, apiUrl, apiKey, ignoreShaCheck = false, lo
         }
     }
     const env = apiUrl === 'https://api.devicecloud.dev' ? 'prod' : 'dev';
-    await SupabaseGateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file);
-    await ApiGateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha);
+    await supabase_gateway_1.SupabaseGateway.uploadToSignedUrl(env, path, token, file);
+    await api_gateway_1.ApiGateway.finaliseUpload(apiUrl, apiKey, id, metadata, path, sha);
     if (log) {
         core_1.ux.action.stop(`\nBinary uploaded with id: ${id}`);
     }
@@ -224,16 +223,16 @@ async function getFileHashFromFile(file) {
         const reader = stream.getReader();
         const processChunks = async () => {
             try {
-                while (true) {
-                    const { done, value } = await reader.read();
-                    if (done)
-                        break;
+                let readerResult = await reader.read();
+                while (!readerResult.done) {
+                    const { value } = readerResult;
                     hash.update(value);
+                    readerResult = await reader.read();
                 }
                 resolve(hash.digest('hex'));
             }
-            catch (err) {
-                reject(err);
+            catch (error) {
+                reject(error);
             }
         };
         processChunks();

package/dist/plan.d.ts

@@ -15,9 +15,9 @@ interface IExecutionOrder {
 interface IExecutionPlan {
     allExcludeTags?: null | string[];
     allIncludeTags?: null | string[];
+    flowMetadata: Record<string, Record<string, unknown>>;
     flowsToRun: string[];
     referencedFiles: string[];
-    flowMetadata: Record<string, Record<string, unknown>>;
     sequence?: IFlowSequence | null;
     totalFlowFiles: number;
     workspaceConfig?: IWorkspaceConfig;

package/dist/plan.js

@@ -42,11 +42,11 @@ function filterFlowFiles(unfilteredFlowFiles, excludeFlows) {
     return unfilteredFlowFiles;
 }
 function getWorkspaceConfig(input, unfilteredFlowFiles) {
-    const possibleConfigPaths = [
+    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.includes(path.normalize(file)));
+    ].map((p) => path.normalize(p)));
+    const configFilePath = unfilteredFlowFiles.find((file) => possibleConfigPaths.has(path.normalize(file)));
     const config = configFilePath
         ? (0, planMethods_1.readYamlFileAsJson)(configFilePath)
         : {};
@@ -69,9 +69,9 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile) {
         }
         const checkedDependancies = await checkDependencies(normalizedInput);
         return {
+            flowMetadata,
             flowsToRun: [normalizedInput],
             referencedFiles: [...new Set(checkedDependancies)],
-            flowMetadata,
             totalFlowFiles: 1,
         };
     }
@@ -184,9 +184,9 @@ async function plan(input, includeTags, excludeTags, excludeFlows, configFile) {
     return {
         allExcludeTags,
         allIncludeTags,
+        flowMetadata,
         flowsToRun: normalFlows,
         referencedFiles: [...new Set(allFiles)],
-        flowMetadata,
         sequence: {
             continueOnFailure: workspaceConfig.executionOrder?.continueOnFailure,
             flows: flowsToRunInSequence,

package/dist/planMethods.d.ts

@@ -6,9 +6,6 @@ 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 readDirectory(dir: string, filterFunction?: (filePath: string) => boolean): Promise<string[]>;
 export declare const checkIfFilesExistInWorkspace: (commandName: string, command: Record<string, string> | string | string[], absoluteFilePath: string) => {

package/dist/planMethods.js

@@ -69,7 +69,7 @@ const readTestYamlFileAsJson = (filePath) => {
         const yamlText = fs.readFileSync(normalizedPath, 'utf8');
         const normalizedText = yamlText
             .replaceAll('\r\n', '\n')
-            .replaceAll(/\n---[ \t]*\n/g, '\n---\n');
+            .replaceAll(/\n---[\t ]*\n/g, '\n---\n');
         if (normalizedText.includes('\n---\n')) {
             const yamlTexts = normalizedText.split('\n---\n');
             const config = yaml.load(yamlTexts[0]);

package/dist/types/device.types.d.ts

@@ -21,16 +21,16 @@ export declare enum EAndroidDevices {
     'pixel-7-pro' = "pixel-7-pro"
 }
 export declare enum EiOSVersions {
-    'sixteen' = "16",
+    'eighteen' = "18",
     'seventeen' = "17",
-    'eighteen' = "18"
+    'sixteen' = "16"
 }
 export declare enum EAndroidApiLevels {
-    'twentyNine' = "29",
     'thirty' = "30",
+    'thirtyFive' = "35",
+    'thirtyFour' = "34",
     'thirtyOne' = "31",
-    'thirtyTwo' = "32",
     'thirtyThree' = "33",
-    'thirtyFour' = "34",
-    'thirtyFive' = "35"
+    'thirtyTwo' = "32",
+    'twentyNine' = "29"
 }

package/dist/types/device.types.js

@@ -27,17 +27,17 @@ var EAndroidDevices;
 })(EAndroidDevices || (exports.EAndroidDevices = EAndroidDevices = {}));
 var EiOSVersions;
 (function (EiOSVersions) {
-    EiOSVersions["sixteen"] = "16";
-    EiOSVersions["seventeen"] = "17";
     EiOSVersions["eighteen"] = "18";
+    EiOSVersions["seventeen"] = "17";
+    EiOSVersions["sixteen"] = "16";
 })(EiOSVersions || (exports.EiOSVersions = EiOSVersions = {}));
 var EAndroidApiLevels;
 (function (EAndroidApiLevels) {
-    EAndroidApiLevels["twentyNine"] = "29";
     EAndroidApiLevels["thirty"] = "30";
+    EAndroidApiLevels["thirtyFive"] = "35";
+    EAndroidApiLevels["thirtyFour"] = "34";
     EAndroidApiLevels["thirtyOne"] = "31";
-    EAndroidApiLevels["thirtyTwo"] = "32";
     EAndroidApiLevels["thirtyThree"] = "33";
-    EAndroidApiLevels["thirtyFour"] = "34";
-    EAndroidApiLevels["thirtyFive"] = "35";
+    EAndroidApiLevels["thirtyTwo"] = "32";
+    EAndroidApiLevels["twentyNine"] = "29";
 })(EAndroidApiLevels || (exports.EAndroidApiLevels = EAndroidApiLevels = {}));