@alfresco/adf-cli 8.5.0-24716296101 → 8.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alfresco/adf-cli",
   "description": "Alfresco ADF cli and utils",
-  "version": "8.5.0-24716296101",
+  "version": "8.5.0",
   "author": "Hyland Software, Inc. and its affiliates",
   "bin": {
     "adf-cli": "bin/adf-cli",
@@ -14,17 +14,9 @@
   "bugs": {
     "url": "https://github.com/Alfresco/alfresco-ng2-components/issues"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "develop": "tsc -p tsconfig.json --watch",
-    "dist": "rm -rf ../../dist/libs/cli && npm run build && cp -R ./bin ../../dist/libs/cli && cp -R ./resources ../../dist/libs/cli && cp -R ./templates ../../dist/libs/cli && cp ./package.json ../../dist/libs/cli",
-    "link": "npm run dist && cd ../../dist/libs/cli && npm link",
-    "unlink": "cd ../../dist/libs/cli && npm unlink"
-  },
   "dependencies": {
-    "@alfresco/js-api": ">=9.5.0-24716296101",
+    "@alfresco/js-api": ">=9.4.0",
     "ejs": "^3.1.10",
-    "license-checker": "^25.0.1",
     "node-fetch": "^2.7.0",
     "spdx-license-list": "^5.0.0"
   },
@@ -36,5 +28,12 @@
     "@types/ejs": "^3.1.2",
     "@types/node": "^20.1.7",
     "typescript": "^4.9.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "develop": "tsc -p tsconfig.json --watch",
+    "dist": "rm -rf ../../dist/libs/cli && npm run build && cp -R ./bin ../../dist/libs/cli && cp -R ./resources ../../dist/libs/cli && cp -R ./templates ../../dist/libs/cli && cp ./package.json ../../dist/libs/cli",
+    "link": "npm run dist && cd ../../dist/libs/cli && npm link",
+    "unlink": "cd ../../dist/libs/cli && npm unlink"
   }
-}
+}

package/resources/license-collector.cjs

@@ -0,0 +1,192 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+function readJson(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function resolvePackageJson(packageName, fromDirectory) {
+    try {
+        return require.resolve(`${packageName}/package.json`, {
+            paths: [fromDirectory]
+        });
+    } catch {
+        return '';
+    }
+}
+
+function getRepositoryUrl(repository) {
+    if (typeof repository === 'string') {
+        return repository;
+    }
+
+    if (repository && typeof repository === 'object' && typeof repository.url === 'string') {
+        return repository.url;
+    }
+
+    return '';
+}
+
+function getRawLicenseExpression(packageJson) {
+    if (typeof packageJson.license === 'string' && packageJson.license.trim()) {
+        return packageJson.license.trim();
+    }
+
+    if (packageJson.license && typeof packageJson.license === 'object' && typeof packageJson.license.type === 'string') {
+        return packageJson.license.type.trim();
+    }
+
+    if (Array.isArray(packageJson.licenses)) {
+        const values = packageJson.licenses
+            .map((entry) => {
+                if (typeof entry === 'string') {
+                    return entry.trim();
+                }
+
+                if (entry && typeof entry === 'object' && typeof entry.type === 'string') {
+                    return entry.type.trim();
+                }
+
+                return '';
+            })
+            .filter(Boolean);
+
+        if (values.length > 0) {
+            return values.join(' OR ');
+        }
+    }
+
+    return 'UNKNOWN';
+}
+
+function extractLicenseTokens(rawExpression) {
+    const tokens = (rawExpression || '').match(/[A-Za-z0-9-.+]+/g) || [];
+    const operators = new Set(['AND', 'OR', 'WITH']);
+
+    return tokens.map((token) => token.toUpperCase()).filter((token) => !operators.has(token));
+}
+
+function hasDeniedLicense(rawExpression, denyList) {
+    const licenseTokens = extractLicenseTokens(rawExpression);
+
+    return denyList.some((rule) => {
+        const normalizedRule = (rule || '').trim().toUpperCase();
+        if (!normalizedRule) {
+            return false;
+        }
+
+        // Treat common copyleft family keywords as SPDX id prefixes.
+        if (normalizedRule === 'GPL' || normalizedRule === 'LGPL' || normalizedRule === 'AGPL') {
+            return licenseTokens.some((token) => token === normalizedRule || token.startsWith(`${normalizedRule}-`));
+        }
+
+        // Support explicit wildcard rules like "GPL-*".
+        if (normalizedRule.endsWith('*')) {
+            const prefix = normalizedRule.slice(0, -1);
+            return prefix.length > 0 && licenseTokens.some((token) => token.startsWith(prefix));
+        }
+
+        // Otherwise require exact SPDX token match.
+        return licenseTokens.includes(normalizedRule);
+    });
+}
+
+function getDependencyNames(packageJson) {
+    return Array.from(new Set([...Object.keys(packageJson.dependencies || {}), ...Object.keys(packageJson.optionalDependencies || {})]));
+}
+
+function collectProductionLicenses(packagePath, options = {}) {
+    const packageJsonFile = readJson(packagePath);
+    const mainDependencies = getDependencyNames(packageJsonFile);
+    const packageDirectory = path.dirname(packagePath);
+    const missingRepositories = options.missingRepositories || {};
+    const denyList = options.denyList || [];
+
+    const queue = mainDependencies.map((name) => ({
+        name,
+        fromDirectory: packageDirectory
+    }));
+
+    const visited = new Set();
+    const packages = [];
+    const deniedPackages = [];
+
+    for (const current of queue) {
+        const packageJsonPath = resolvePackageJson(current.name, current.fromDirectory);
+
+        if (!packageJsonPath || !fs.existsSync(packageJsonPath)) {
+            continue;
+        }
+
+        const currentPackage = readJson(packageJsonPath);
+        const name = currentPackage.name || current.name;
+        const version = currentPackage.version || 'unknown';
+        const packageFolder = path.dirname(packageJsonPath);
+        const uniqueKey = `${name}@${version}:${packageFolder}`;
+
+        if (visited.has(uniqueKey)) {
+            continue;
+        }
+        visited.add(uniqueKey);
+
+        const rawLicenseExpression = getRawLicenseExpression(currentPackage);
+        const packageKey = `${name}@${version}`;
+        const repository = getRepositoryUrl(currentPackage.repository) || missingRepositories[name] || '';
+
+        const record = {
+            key: packageKey,
+            name,
+            version,
+            repository,
+            rawLicenseExpression,
+            dependencies: currentPackage.dependencies || {},
+            optionalDependencies: currentPackage.optionalDependencies || {}
+        };
+
+        packages.push(record);
+
+        if (hasDeniedLicense(rawLicenseExpression, denyList)) {
+            deniedPackages.push(`${packageKey}: ${rawLicenseExpression}`);
+        }
+
+        const dependencies = getDependencyNames(currentPackage);
+        for (const dependencyName of dependencies) {
+            queue.push({
+                name: dependencyName,
+                fromDirectory: packageFolder
+            });
+        }
+    }
+
+    packages.sort((a, b) => {
+        const nameCompare = a.name.localeCompare(b.name);
+        if (nameCompare !== 0) {
+            return nameCompare;
+        }
+
+        return a.version.localeCompare(b.version);
+    });
+
+    return { packages, deniedPackages };
+}
+
+module.exports = {
+    collectProductionLicenses
+};

package/scripts/init-acs-env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init-acs-env.d.ts","sourceRoot":"","sources":["../../../../lib/cli/scripts/init-acs-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAsBH;;GAEG;AACH,wBAA8B,IAAI,kBAwDjC"}
+{"version":3,"file":"init-acs-env.d.ts","sourceRoot":"","sources":["../../../../lib/cli/scripts/init-acs-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AA0BH;;GAEG;AACH,wBAA8B,IAAI,kBAkDjC"}

package/scripts/init-acs-env.js

@@ -57,10 +57,13 @@ const fs_1 = require("fs");
 const path = __importStar(require("path"));
 const logger_1 = require("./logger");
 const MAX_RETRY = 10;
-let counter = 0;
-const TIMEOUT = 6000;
+const RETRY_DELAY_MS = 6000;
 const ACS_DEFAULT = require('./resources').ACS_DEFAULT;
 let alfrescoJsApi;
+let nodesApi;
+let uploadApi;
+let sharedlinksApi;
+let favoritesApi;
 /**
  * Init ACS environment command
  */
@@ -72,7 +75,6 @@ Usage: init-acs-env [options]
 Initialize ACS environment
 
 Options:
-  -v, --version         Output the version number
   --host <host>         Remote environment host
   --clientId <id>       SSO client (default: "alfresco")
   -p, --password <pass> Password
@@ -81,10 +83,6 @@ Options:
 `);
         (0, node_process_1.exit)(0);
     }
-    if (node_process_1.argv.includes('-v') || node_process_1.argv.includes('--version')) {
-        console.log('0.1.0');
-        (0, node_process_1.exit)(0);
-    }
     const { values } = (0, node_util_1.parseArgs)({
         args: node_process_1.argv.slice(2),
         options: {
@@ -113,156 +111,266 @@ Options:
         password: values.password
     };
     await checkEnv(opts);
-    logger_1.logger.info(`***** Step initialize ACS *****`);
+    logger_1.logger.info('***** Step initialize ACS *****');
     await initializeDefaultFiles();
 }
 /**
- * Setup default files
+ * Initialize default files. Creates the e2e folder and ensures each file
+ * exists with its required state (locked, shared, favorite).
+ * Idempotent: only creates/modifies what is missing.
  */
 async function initializeDefaultFiles() {
-    const e2eFolder = ACS_DEFAULT.e2eFolder;
-    const parentFolder = await createFolder(e2eFolder.name, '-my-');
-    const parentFolderId = parentFolder.entry.id;
-    for (let j = 0; j < ACS_DEFAULT.files.length; j++) {
-        const fileInfo = ACS_DEFAULT.files[j];
-        switch (fileInfo.action) {
-            case 'UPLOAD': {
-                await uploadFile(fileInfo.name, parentFolderId);
-                break;
-            }
-            case 'LOCK': {
-                const fileToLock = await uploadFile(fileInfo.name, parentFolderId);
-                await lockFile(fileToLock.entry.id);
-                break;
-            }
-            case 'SHARE': {
-                const fileToShare = await uploadFile(fileInfo.name, parentFolderId);
-                await shareFile(fileToShare.entry.id);
-                break;
-            }
-            case 'FAVORITE': {
-                const fileToFav = await uploadFile(fileInfo.name, parentFolderId);
-                await favoriteFile(fileToFav.entry.id);
-                break;
-            }
-            default: {
-                logger_1.logger.error('No action found for file ', fileInfo.name, parentFolderId);
-                break;
-            }
-        }
+    const e2eFolderName = ACS_DEFAULT.e2eFolder.name;
+    let parentFolder;
+    try {
+        parentFolder = await withRetry(() => ensureFolder(e2eFolderName, '-my-'), `ensure folder ${e2eFolderName}`);
+    }
+    catch (error) {
+        logger_1.logger.warn(`Skipping file initialization: test-data folder could not be created: ${formatError(error)}`);
+        return;
+    }
+    const parentFolderId = getEntryId(parentFolder, `folder ${e2eFolderName}`);
+    for (const fileInfo of ACS_DEFAULT.files) {
+        await withRetry(() => processFile(fileInfo, parentFolderId), `initialize ${fileInfo.name}`);
     }
 }
 /**
- * Create folder
- *
+ * Process a single file: upload if missing, then apply its action (lock/share/favorite).
+ * @param fileInfo file descriptor from ACS_DEFAULT
+ * @param fileInfo.name file name
+ * @param fileInfo.action action to apply (LOCK, SHARE, FAVORITE)
+ * @param parentFolderId parent folder node id
+ */
+async function processFile(fileInfo, parentFolderId) {
+    const existingNode = await findNodeByRelativePath(parentFolderId, fileInfo.name);
+    let nodeId;
+    if (existingNode?.entry?.id) {
+        logger_1.logger.info(`File ${fileInfo.name} already exists, verifying required state.`);
+        nodeId = existingNode.entry.id;
+    }
+    else {
+        const createdNode = await uploadFile(fileInfo.name, parentFolderId);
+        nodeId = getEntryId(createdNode, `file ${fileInfo.name}`);
+    }
+    switch (fileInfo.action) {
+        case 'LOCK':
+            await ensureLocked(nodeId, fileInfo.name, existingNode?.entry?.isLocked);
+            break;
+        case 'SHARE':
+            await ensureShared(nodeId, fileInfo.name);
+            break;
+        case 'FAVORITE':
+            await ensureFavorite(nodeId, fileInfo.name);
+            break;
+        default:
+            break;
+    }
+}
+/**
+ * Ensure a folder exists under the given parent. Creates it if missing.
+ * Handles 409 conflict (race condition) by fetching the existing folder.
  * @param folderName folder name
- * @param parentId parent folder id
+ * @param parentId parent node id
+ * @returns the folder node entry
  */
-async function createFolder(folderName, parentId) {
-    let createdFolder;
-    const body = {
-        name: folderName,
-        nodeType: 'cm:folder'
-    };
+async function ensureFolder(folderName, parentId) {
+    const existingFolder = await findNodeByRelativePath(parentId, folderName);
+    if (existingFolder?.entry?.id) {
+        if (!existingFolder.entry.isFolder) {
+            throw new Error(`Cannot use ${folderName} as test-data folder: a non-folder node with that name already exists (nodeType: ${existingFolder.entry.nodeType}, id: ${existingFolder.entry.id}).`);
+        }
+        logger_1.logger.info(`Folder ${folderName} already exists.`);
+        return existingFolder;
+    }
     try {
-        createdFolder = await new js_api_1.NodesApi(alfrescoJsApi).createNode(parentId, body, { overwrite: true });
+        const createdFolder = await nodesApi.createNode(parentId, { name: folderName, nodeType: 'cm:folder' }, { overwrite: true });
         logger_1.logger.info(`Folder ${folderName} was created`);
+        return createdFolder;
     }
-    catch (err) {
-        if (err.status === 409) {
-            const relativePath = `/${folderName}`;
-            createdFolder = await new js_api_1.NodesApi(alfrescoJsApi).getNode('-my-', { relativePath });
+    catch (error) {
+        if (error?.status === 409) {
+            const conflictingFolder = await findNodeByRelativePath(parentId, folderName);
+            if (conflictingFolder?.entry?.id) {
+                if (!conflictingFolder.entry.isFolder) {
+                    throw new Error(`Cannot use ${folderName} as test-data folder: a non-folder node with that name already exists (nodeType: ${conflictingFolder.entry.nodeType}, id: ${conflictingFolder.entry.id}).`);
+                }
+                logger_1.logger.info(`Folder ${folderName} already exists.`);
+                return conflictingFolder;
+            }
         }
+        throw new Error(`Failed to ensure folder ${folderName}: ${formatError(error)}`);
     }
-    return createdFolder;
 }
 /**
- * Upload file
- *
+ * Find a node by relative path under a parent. Returns null if not found (404).
+ * @param parentId parent node id
+ * @param fileName relative path / file name
+ * @returns the node entry or null if not found
+ */
+async function findNodeByRelativePath(parentId, fileName) {
+    try {
+        return await nodesApi.getNode(parentId, { relativePath: `/${fileName}`, include: ['isLocked'] });
+    }
+    catch (error) {
+        if (error?.status === 404) {
+            return null;
+        }
+        throw new Error(`Failed to fetch ${fileName}: ${formatError(error)}`);
+    }
+}
+/**
+ * Upload a file to the given destination folder.
  * @param fileName file name
- * @param fileDestination destination path
+ * @param destinationId destination folder node id
+ * @returns the uploaded node entry
  */
-async function uploadFile(fileName, fileDestination) {
+async function uploadFile(fileName, destinationId) {
     const filePath = `../resources/content/${fileName}`;
     const file = (0, fs_1.createReadStream)(path.join(__dirname, filePath));
-    let uploadedFile;
     try {
-        uploadedFile = await new js_api_1.UploadApi(alfrescoJsApi).uploadFile(file, '', fileDestination, null, {
+        const uploadedFile = await uploadApi.uploadFile(file, '', destinationId, null, {
             name: fileName,
             nodeType: 'cm:content',
             renditions: 'doclib',
             overwrite: true
         });
         logger_1.logger.info(`File ${fileName} was uploaded`);
+        return uploadedFile;
     }
-    catch (err) {
-        logger_1.logger.error(`Failed to upload file with error: `, err.stack);
+    catch (error) {
+        throw new Error(`Failed to upload ${fileName}: ${formatError(error)}`);
     }
-    return uploadedFile;
 }
 /**
- * Lock file node
- *
+ * Ensure a file is locked. Skips if already locked.
  * @param nodeId node id
+ * @param fileName file name (for logging)
+ * @param isAlreadyLocked whether the node is already locked
  */
-async function lockFile(nodeId) {
-    const data = {
-        type: 'ALLOW_OWNER_CHANGES'
-    };
+async function ensureLocked(nodeId, fileName, isAlreadyLocked = false) {
+    if (isAlreadyLocked) {
+        logger_1.logger.info(`File ${fileName} is already locked.`);
+        return;
+    }
     try {
-        const result = new js_api_1.NodesApi(alfrescoJsApi).lockNode(nodeId, data);
-        logger_1.logger.info('File was locked');
-        return result;
+        await nodesApi.lockNode(nodeId, { type: 'ALLOW_OWNER_CHANGES' });
+        logger_1.logger.info(`File ${fileName} was locked`);
     }
     catch (error) {
-        logger_1.logger.error('Failed to lock file with error: ', error.stack);
-        return null;
+        throw new Error(`Failed to lock ${fileName}: ${formatError(error)}`);
     }
 }
 /**
- * Share file node
- *
+ * Ensure a file is shared. Handles 409 (already shared) gracefully.
  * @param nodeId node id
+ * @param fileName file name (for logging)
  */
-async function shareFile(nodeId) {
-    const data = {
-        nodeId
-    };
+async function ensureShared(nodeId, fileName) {
     try {
-        await new js_api_1.SharedlinksApi(alfrescoJsApi).createSharedLink(data);
-        logger_1.logger.info('File was shared');
+        await sharedlinksApi.createSharedLink({ nodeId });
+        logger_1.logger.info(`File ${fileName} was shared`);
     }
     catch (error) {
-        logger_1.logger.error('Failed to share file with error: ', error.stack);
+        if (error?.status === 409) {
+            logger_1.logger.info(`File ${fileName} is already shared.`);
+            return;
+        }
+        throw new Error(`Failed to share ${fileName}: ${formatError(error)}`);
     }
 }
 /**
- * Favorite file node
- *
+ * Ensure a file is favorite. Handles 409 (already favorite) gracefully.
  * @param nodeId node id
+ * @param fileName file name (for logging)
  */
-async function favoriteFile(nodeId) {
-    const data = {
-        target: {
-            ['file']: {
-                guid: nodeId
+async function ensureFavorite(nodeId, fileName) {
+    try {
+        await favoritesApi.createFavorite('-me-', {
+            target: {
+                file: {
+                    guid: nodeId
+                }
             }
+        });
+        logger_1.logger.info(`File ${fileName} was added to favorites`);
+    }
+    catch (error) {
+        if (error?.status === 409) {
+            logger_1.logger.info(`File ${fileName} is already a favorite.`);
+            return;
         }
-    };
+        throw new Error(`Failed to favorite ${fileName}: ${formatError(error)}`);
+    }
+}
+/**
+ * Extract entry id from a node response. Throws if missing.
+ * @param nodeEntry node entry response
+ * @param label label for error message
+ * @returns the node id
+ */
+function getEntryId(nodeEntry, label) {
+    const nodeId = nodeEntry?.entry?.id;
+    if (nodeId) {
+        return nodeId;
+    }
+    throw new Error(`Missing ACS response entry for ${label}.`);
+}
+/**
+ * Format an error for logging.
+ * @param error error object
+ * @returns formatted error string
+ */
+function formatError(error) {
+    if (!error) {
+        return 'Unknown error';
+    }
+    if (typeof error === 'string') {
+        return error;
+    }
     try {
-        await new js_api_1.FavoritesApi(alfrescoJsApi).createFavorite('-me-', data);
-        logger_1.logger.info('File was add to favorites');
+        return error?.message || error?.stack || JSON.stringify(error);
     }
-    catch (error) {
-        logger_1.logger.error('Failed to add the file to favorites with error: ', error.stack);
+    catch {
+        return 'Unknown error (unable to serialize)';
     }
 }
 /**
- * Check environment state
- *
+ * Retry wrapper for transient failures.
+ * @param fn async function to execute
+ * @param label label for logging
+ * @param maxAttempts maximum retry attempts
+ * @returns the result of the function
+ */
+async function withRetry(fn, label, maxAttempts = 3) {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt === maxAttempts) {
+                logger_1.logger.error(`${label}: failed after ${maxAttempts} attempts: ${formatError(error)}`);
+                throw error;
+            }
+            logger_1.logger.warn(`${label}: attempt ${attempt} failed, retrying in ${RETRY_DELAY_MS / 1000}s: ${formatError(error)}`);
+            await wait(RETRY_DELAY_MS);
+        }
+    }
+    throw new Error(`${label}: exhausted all ${maxAttempts} attempts`);
+}
+/**
+ * Async delay.
+ * @param ms milliseconds to wait
+ * @returns a promise that resolves after the delay
+ */
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check environment state and authenticate. Retries on transient failures.
  * @param opts command options
+ * @param attempt current attempt number
  */
-async function checkEnv(opts) {
+async function checkEnv(opts, attempt = 1) {
     try {
         alfrescoJsApi = new js_api_1.AlfrescoApi({
             provider: 'ALL',
@@ -278,32 +386,26 @@ async function checkEnv(opts) {
             contextRoot: 'alfresco'
         });
         await alfrescoJsApi.login(opts.username, opts.password);
+        nodesApi = new js_api_1.NodesApi(alfrescoJsApi);
+        uploadApi = new js_api_1.UploadApi(alfrescoJsApi);
+        sharedlinksApi = new js_api_1.SharedlinksApi(alfrescoJsApi);
+        favoritesApi = new js_api_1.FavoritesApi(alfrescoJsApi);
     }
-    catch (e) {
-        if (e.error.code === 'ETIMEDOUT') {
-            logger_1.logger.error('The env is not reachable. Terminating');
-            (0, node_process_1.exit)(1);
+    catch (error) {
+        const errorCode = error?.error?.code;
+        if (errorCode === 'ETIMEDOUT' || error?.status === 504) {
+            logger_1.logger.warn('Login attempt timed out or received a gateway error, environment may still be starting up.');
+        }
+        else {
+            logger_1.logger.error('Login error, environment down or inaccessible.');
         }
-        logger_1.logger.error('Login error environment down or inaccessible');
-        counter++;
-        if (MAX_RETRY === counter) {
+        if (attempt >= MAX_RETRY) {
             logger_1.logger.error('Give up');
             (0, node_process_1.exit)(1);
         }
-        else {
-            logger_1.logger.error(`Retry in 1 minute attempt N ${counter}`);
-            sleep(TIMEOUT);
-            await checkEnv(opts);
-        }
+        logger_1.logger.warn(`Retry in ${RETRY_DELAY_MS / 1000} seconds, attempt ${attempt}`);
+        await wait(RETRY_DELAY_MS);
+        await checkEnv(opts, attempt + 1);
     }
 }
-/**
- * Perform a delay
- *
- * @param delay timeout in milliseconds
- */
-function sleep(delay) {
-    const start = new Date().getTime();
-    while (new Date().getTime() < start + delay) { }
-}
 //# sourceMappingURL=init-acs-env.js.map