apify-cli 0.19.3-beta.5 → 1.0.0-beta.0

package/{src → dist}/lib/utils.js

@@ -1,241 +1,183 @@
-const {
-    execSync,
-    spawnSync,
-} = require('child_process');
-const fs = require('fs');
-const https = require('https');
-const path = require('path');
-const { finished } = require('stream');
-const { promisify } = require('util');
-
-const {
-    ACT_JOB_TERMINAL_STATUSES,
-    ACTOR_ENV_VARS,
-    LOCAL_ACTOR_ENV_VARS,
-    ACTOR_NAME,
-    APIFY_ENV_VARS,
-    KEY_VALUE_STORE_KEYS,
-    LOCAL_STORAGE_SUBDIRS,
-    SOURCE_FILE_FORMATS,
-} = require('@apify/consts');
-const AdmZip = require('adm-zip');
-const { ApifyClient } = require('apify-client');
-const archiver = require('archiver-promise');
-const axios = require('axios');
-const escapeStringRegexp = require('escape-string-regexp');
-const globby = require('globby');
-const inquirer = require('inquirer');
-const { getEncoding } = require('istextorbinary');
-const loadJson = require('load-json-file');
-const mime = require('mime');
-const semver = require('semver');
-const _ = require('underscore');
-const writeJson = require('write-json-file');
-
-const {
-    GLOBAL_CONFIGS_FOLDER,
-    AUTH_FILE_PATH,
-    INPUT_FILE_REG_EXP,
-    DEFAULT_LOCAL_STORAGE_DIR,
-    LOCAL_CONFIG_PATH,
-    DEPRECATED_LOCAL_CONFIG_NAME,
-    ACTOR_SPECIFICATION_VERSION,
-    APIFY_CLIENT_DEFAULT_HEADERS,
-    SUPPORTED_NODEJS_VERSION,
-    MINIMUM_SUPPORTED_PYTHON_VERSION,
-    LANGUAGE,
-    PROJECT_TYPES,
-} = require('./consts');
-const {
-    ensureFolderExistsSync,
-    rimrafPromised,
-    deleteFile,
-} = require('./files');
-const {
-    info,
-} = require('./outputs');
-const { ProjectAnalyzer } = require('./project_analyzer');
-
-/**
- * @param {string} url
- * @returns {Promise<unknown>}
- */
-const httpsGet = async (url) => {
+import { spawnSync } from 'node:child_process';
+import { createWriteStream, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { get } from 'node:https';
+import { dirname, join } from 'node:path';
+import process from 'node:process';
+import { finished } from 'node:stream/promises';
+import { ACTOR_ENV_VARS, ACTOR_JOB_TERMINAL_STATUSES, ACTOR_NAME, APIFY_ENV_VARS, KEY_VALUE_STORE_KEYS, LOCAL_ACTOR_ENV_VARS, LOCAL_STORAGE_SUBDIRS, SOURCE_FILE_FORMATS, } from '@apify/consts';
+import AdmZip from 'adm-zip';
+import _Ajv from 'ajv';
+import { ApifyClient } from 'apify-client';
+import archiver from 'archiver';
+import { AxiosHeaders } from 'axios';
+import escapeStringRegexp from 'escape-string-regexp';
+import { globby } from 'globby';
+import inquirer from 'inquirer';
+import { getEncoding } from 'istextorbinary';
+import { loadJsonFile, loadJsonFileSync } from 'load-json-file';
+import { Mime } from 'mime';
+import otherMimes from 'mime/types/other.js';
+import standardMimes from 'mime/types/standard.js';
+import { gte, minVersion, satisfies } from 'semver';
+import _ from 'underscore';
+import { writeJsonFile, writeJsonFileSync } from 'write-json-file';
+import { ACTOR_SPECIFICATION_VERSION, APIFY_CLIENT_DEFAULT_HEADERS, AUTH_FILE_PATH, DEFAULT_LOCAL_STORAGE_DIR, DEPRECATED_LOCAL_CONFIG_NAME, GLOBAL_CONFIGS_FOLDER, INPUT_FILE_REG_EXP, LANGUAGE, LOCAL_CONFIG_PATH, MINIMUM_SUPPORTED_PYTHON_VERSION, PROJECT_TYPES, SUPPORTED_NODEJS_VERSION, } from './consts.js';
+import { deleteFile, ensureFolderExistsSync, rimrafPromised } from './files.js';
+import { info } from './outputs.js';
+import { ProjectAnalyzer } from './project_analyzer.js';
+// Export AJV properly: https://github.com/ajv-validator/ajv/issues/2132
+// Welcome to the state of JavaScript/TypeScript and CJS/ESM interop.
+export const Ajv = _Ajv;
+export const httpsGet = async (url) => {
     return new Promise((resolve, reject) => {
-        https.get(url, (response) => {
+        get(url, (response) => {
             // Handle redirects
             if (response.statusCode === 301 || response.statusCode === 302) {
                 resolve(httpsGet(response.headers.location));
                 // Destroy the response to close the HTTP connection, otherwise this hangs for a long time with Node 19+ (due to HTTP keep-alive).
                 response.destroy();
-            } else {
+            }
+            else {
                 resolve(response);
             }
         }).on('error', reject);
     });
 };
-
 // Properties from apify.json file that will me migrated to actor specs in .actor/actor.json
 const MIGRATED_APIFY_JSON_PROPERTIES = ['name', 'version', 'buildTag'];
-
-const getLocalStorageDir = () => {
+export const getLocalStorageDir = () => {
     const envVar = APIFY_ENV_VARS.LOCAL_STORAGE_DIR;
-
     return process.env[envVar] || process.env.CRAWLEE_STORAGE_DIR || DEFAULT_LOCAL_STORAGE_DIR;
 };
-const getLocalKeyValueStorePath = (storeId) => {
+export const getLocalKeyValueStorePath = (storeId) => {
     const envVar = ACTOR_ENV_VARS.DEFAULT_KEY_VALUE_STORE_ID;
     const storeDir = storeId || process.env[envVar] || LOCAL_ACTOR_ENV_VARS[envVar];
-
-    return path.join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.keyValueStores, storeDir);
+    return join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.keyValueStores, storeDir);
 };
-const getLocalDatasetPath = (storeId) => {
+export const getLocalDatasetPath = (storeId) => {
     const envVar = ACTOR_ENV_VARS.DEFAULT_DATASET_ID;
     const storeDir = storeId || process.env[envVar] || LOCAL_ACTOR_ENV_VARS[envVar];
-
-    return path.join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.datasets, storeDir);
+    return join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.datasets, storeDir);
 };
-const getLocalRequestQueuePath = (storeId) => {
+export const getLocalRequestQueuePath = (storeId) => {
     const envVar = ACTOR_ENV_VARS.DEFAULT_REQUEST_QUEUE_ID;
     const storeDir = storeId || process.env[envVar] || LOCAL_ACTOR_ENV_VARS[envVar];
-
-    return path.join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.requestQueues, storeDir);
+    return join(getLocalStorageDir(), LOCAL_STORAGE_SUBDIRS.requestQueues, storeDir);
 };
-
 /**
  * Returns object from auth file or empty object.
- * @return {*}
  */
-const getLocalUserInfo = () => {
+export const getLocalUserInfo = async () => {
     try {
-        return loadJson.sync(AUTH_FILE_PATH) || {};
-    } catch (e) {
+        const result = await loadJsonFile(AUTH_FILE_PATH());
+        return (result || {});
+    }
+    catch {
         return {};
     }
 };
-
 /**
  * Gets instance of ApifyClient for user otherwise throws error
- * @return {Promise<boolean|*>}
  */
-const getLoggedClientOrThrow = async () => {
+export const getLoggedClientOrThrow = async () => {
     const loggedClient = await getLoggedClient();
     if (!loggedClient) {
         throw new Error('You are not logged in with your Apify account. Call "apify login" to fix that.');
     }
     return loggedClient;
 };
-
+const getTokenWithAuthFileFallback = (existingToken) => {
+    if (!existingToken && existsSync(GLOBAL_CONFIGS_FOLDER()) && existsSync(AUTH_FILE_PATH())) {
+        return loadJsonFileSync(AUTH_FILE_PATH()).token;
+    }
+    return existingToken;
+};
 /**
  * Returns options for ApifyClient
- * @param {String|null|undefined} token
- * @returns {Object}
  */
-const getApifyClientOptions = (token, apiBaseUrl) => {
-    if (!token && fs.existsSync(GLOBAL_CONFIGS_FOLDER) && fs.existsSync(AUTH_FILE_PATH)) {
-        ({ token } = loadJson.sync(AUTH_FILE_PATH));
-    }
-
+export const getApifyClientOptions = (token, apiBaseUrl) => {
+    token = getTokenWithAuthFileFallback(token);
     return {
         token,
         baseUrl: apiBaseUrl || process.env.APIFY_CLIENT_BASE_URL,
         requestInterceptors: [(config) => {
-            if (!config.headers) {
-                config.headers = new axios.AxiosHeaders();
-            }
-
-            for (const [key, value] of Object.entries(APIFY_CLIENT_DEFAULT_HEADERS)) {
-                config.headers[key] = value;
-            }
-
-            return config;
-        }],
+                // @ts-expect-error CLI is ESM, client is CJS, the types "differ"
+                config.headers ?? (config.headers = new AxiosHeaders());
+                for (const [key, value] of Object.entries(APIFY_CLIENT_DEFAULT_HEADERS)) {
+                    config.headers[key] = value;
+                }
+                return config;
+            }],
     };
 };
-
 /**
  * Gets instance of ApifyClient for token or for params from global auth file.
  * NOTE: It refreshes global auth file each run
  * @param [token]
- * @return {Promise<*>}
  */
-const getLoggedClient = async (token, apiBaseUrl) => {
-    if (!token && fs.existsSync(GLOBAL_CONFIGS_FOLDER) && fs.existsSync(AUTH_FILE_PATH)) {
-        ({ token } = loadJson.sync(AUTH_FILE_PATH));
-    }
-
+export const getLoggedClient = async (token, apiBaseUrl) => {
+    token = getTokenWithAuthFileFallback(token);
     const apifyClient = new ApifyClient(getApifyClientOptions(token, apiBaseUrl));
     let userInfo;
     try {
         userInfo = await apifyClient.user('me').get();
-    } catch (e) {
-        return false;
     }
-
+    catch (err) {
+        return null;
+    }
     // Always refresh Auth file
-    if (!fs.existsSync(GLOBAL_CONFIGS_FOLDER)) fs.mkdirSync(GLOBAL_CONFIGS_FOLDER);
-    writeJson.sync(AUTH_FILE_PATH, { token: apifyClient.token, ...userInfo });
+    ensureApifyDirectory(AUTH_FILE_PATH());
+    await writeJsonFile(AUTH_FILE_PATH(), { token: apifyClient.token, ...userInfo });
     return apifyClient;
 };
-
-const getLocalConfigPath = () => path.join(process.cwd(), LOCAL_CONFIG_PATH);
-
+const getLocalConfigPath = (cwd) => join(cwd, LOCAL_CONFIG_PATH);
 /**
  * @deprecated Use getLocalConfigPath
- * @returns {string}
  */
-const getDeprecatedLocalConfigPath = () => path.join(process.cwd(), DEPRECATED_LOCAL_CONFIG_NAME);
-
-const getJsonFileContent = (filePath) => {
-    if (!fs.existsSync(filePath)) {
+const getDeprecatedLocalConfigPath = (cwd) => join(cwd, DEPRECATED_LOCAL_CONFIG_NAME);
+export const getJsonFileContent = (filePath) => {
+    if (!existsSync(filePath)) {
         return;
     }
-    return loadJson.sync(filePath);
+    return loadJsonFileSync(filePath);
 };
-
-const getLocalConfig = () => getJsonFileContent(getLocalConfigPath());
-
+export const getLocalConfig = (cwd) => getJsonFileContent(getLocalConfigPath(cwd));
 /**
  * @deprecated Use getLocalConfig
- * @returns {string}
  */
-const getDeprecatedLocalConfig = () => getJsonFileContent(getDeprecatedLocalConfigPath());
-
-const getLocalConfigOrThrow = async () => {
-    let localConfig = getLocalConfig();
-    let deprecatedLocalConfig = getDeprecatedLocalConfig();
-
+const getDeprecatedLocalConfig = (cwd) => getJsonFileContent(getDeprecatedLocalConfigPath(cwd));
+export const getLocalConfigOrThrow = async (cwd) => {
+    let localConfig = getLocalConfig(cwd);
+    let deprecatedLocalConfig = getDeprecatedLocalConfig(cwd);
     if (localConfig && deprecatedLocalConfig) {
         const answer = await inquirer.prompt([{
-            name: 'isConfirm',
-            type: 'confirm',
-
-            message: `The new version of Apify CLI uses the "${LOCAL_CONFIG_PATH}" instead of the "apify.json" file. Since we have found both files in your Actor directory, "apify.json" will be renamed to "apify.json.deprecated". Going forward, all commands will use "${LOCAL_CONFIG_PATH}". You can read about the differences between the old and the new config at https://github.com/apify/apify-cli/blob/master/MIGRATIONS.md. Do you want to continue?`,
-        }]);
+                name: 'isConfirm',
+                type: 'confirm',
+                message: `The new version of Apify CLI uses the "${LOCAL_CONFIG_PATH}" instead of the "apify.json" file. Since we have found both files in your Actor directory, "apify.json" will be renamed to "apify.json.deprecated". Going forward, all commands will use "${LOCAL_CONFIG_PATH}". You can read about the differences between the old and the new config at https://github.com/apify/apify-cli/blob/master/MIGRATIONS.md. Do you want to continue?`,
+            }]);
         if (!answer.isConfirm) {
             throw new Error('Command can not run with old "apify.json" file present in your Actor directory., Please, either rename or remove it.');
         }
         try {
-            fs.renameSync(getDeprecatedLocalConfigPath(), `${getDeprecatedLocalConfigPath()}.deprecated`);
+            renameSync(getDeprecatedLocalConfigPath(cwd), `${getDeprecatedLocalConfigPath(cwd)}.deprecated`);
             // eslint-disable-next-line max-len
             info(`The "apify.json" file has been renamed to "apify.json.deprecated". The deprecated file is no longer used by the CLI or Apify Console. If you do not need it for some specific purpose, it can be safely deleted.`);
-        } catch (e) {
+        }
+        catch (e) {
             throw new Error('Failed to rename deprecated "apify.json".');
         }
     }
-
     if (!localConfig && !deprecatedLocalConfig) {
         return {};
     }
-
     // If apify.json exists migrate it to .actor/actor.json
     if (!localConfig && deprecatedLocalConfig) {
         const answer = await inquirer.prompt([{
-            name: 'isConfirm',
-            type: 'confirm',
-            // eslint-disable-next-line max-len
-            message: `The new version of Apify CLI uses the "${LOCAL_CONFIG_PATH}" instead of the "apify.json" file. Your "apify.json" file will be automatically updated to the new format under "${LOCAL_CONFIG_PATH}". The original file will be renamed by adding the ".deprecated" suffix. Do you want to continue?`,
-        }]);
+                name: 'isConfirm',
+                type: 'confirm',
+                // eslint-disable-next-line max-len
+                message: `The new version of Apify CLI uses the "${LOCAL_CONFIG_PATH}" instead of the "apify.json" file. Your "apify.json" file will be automatically updated to the new format under "${LOCAL_CONFIG_PATH}". The original file will be renamed by adding the ".deprecated" suffix. Do you want to continue?`,
+            }]);
         if (!answer.isConfirm) {
             throw new Error('Command can not run with old apify.json structure. Either let the CLI auto-update it or follow the guide on https://github.com/apify/apify-cli/blob/master/MIGRATIONS.md and update it manually.');
         }
@@ -246,87 +188,77 @@ const getLocalConfigOrThrow = async () => {
             }
             localConfig = {
                 actorSpecification: ACTOR_SPECIFICATION_VERSION,
-                environmentVariables: deprecatedLocalConfig.env || undefined,
+                environmentVariables: deprecatedLocalConfig?.env || undefined,
                 ..._.pick(deprecatedLocalConfig, MIGRATED_APIFY_JSON_PROPERTIES),
             };
-
-            writeJson.sync(getLocalConfigPath(), localConfig);
-            fs.renameSync(getDeprecatedLocalConfigPath(), `${getDeprecatedLocalConfigPath()}.deprecated`);
+            await writeJsonFile(getLocalConfigPath(cwd), localConfig);
+            renameSync(getDeprecatedLocalConfigPath(cwd), `${getDeprecatedLocalConfigPath(cwd)}.deprecated`);
             // eslint-disable-next-line max-len
             info(`The "apify.json" file has been migrated to "${LOCAL_CONFIG_PATH}" and the original file renamed to "apify.json.deprecated". The deprecated file is no longer used by the CLI or Apify Console. If you do not need it for some specific purpose, it can be safely deleted. Do not forget to commit the new file to your Git repository.`);
-        } catch (e) {
+        }
+        catch (e) {
             throw new Error(`Can not update "${LOCAL_CONFIG_PATH}" structure. Follow guide on https://github.com/apify/apify-cli/blob/master/MIGRATIONS.md and update it manually.`);
         }
     }
-
     return localConfig;
 };
-
-const setLocalConfig = async (localConfig, actDir) => {
+export const setLocalConfig = async (localConfig, actDir) => {
     actDir = actDir || process.cwd();
-    writeJson.sync(path.join(actDir, LOCAL_CONFIG_PATH), localConfig);
+    writeJsonFileSync(join(actDir, LOCAL_CONFIG_PATH), localConfig);
 };
-
 const GITIGNORE_REQUIRED_CONTENTS = [getLocalStorageDir(), 'node_modules', '.venv'];
-
-const setLocalEnv = async (actDir) => {
+export const setLocalEnv = async (actDir) => {
     // Create folders for emulation Apify stores
     const keyValueStorePath = getLocalKeyValueStorePath();
     ensureFolderExistsSync(actDir, getLocalDatasetPath());
     ensureFolderExistsSync(actDir, getLocalRequestQueuePath());
     ensureFolderExistsSync(actDir, keyValueStorePath);
-
     // Create or update gitignore
-    const gitignorePath = path.join(actDir, '.gitignore');
+    const gitignorePath = join(actDir, '.gitignore');
     let gitignoreContents = '';
-    if (fs.existsSync(gitignorePath)) {
-        gitignoreContents = fs.readFileSync(gitignorePath, { encoding: 'utf-8' });
+    if (existsSync(gitignorePath)) {
+        gitignoreContents = readFileSync(gitignorePath, { encoding: 'utf-8' });
     }
-
     const gitignoreAdditions = [];
     for (const gitignoreRequirement of GITIGNORE_REQUIRED_CONTENTS) {
         if (!RegExp(`^${escapeStringRegexp(gitignoreRequirement)}$`, 'mg').test(gitignoreContents)) {
             gitignoreAdditions.push(gitignoreRequirement);
         }
     }
-
     if (gitignoreAdditions.length > 0) {
         if (gitignoreContents.length > 0) {
             gitignoreAdditions.unshift('# Added by Apify CLI');
-            fs.writeFileSync(gitignorePath, `\n${gitignoreAdditions.join('\n')}\n`, { flag: 'a' });
-        } else {
-            fs.writeFileSync(gitignorePath, `${gitignoreAdditions.join('\n')}\n`, { flag: 'w' });
+            writeFileSync(gitignorePath, `\n${gitignoreAdditions.join('\n')}\n`, { flag: 'a' });
+        }
+        else {
+            writeFileSync(gitignorePath, `${gitignoreAdditions.join('\n')}\n`, { flag: 'w' });
         }
     }
 };
-
 /**
  * Convert Object with kebab-case keys to camelCased keys
- *
- * @param object
- * @return {{}}
  */
-const argsToCamelCase = (object) => {
+export const argsToCamelCase = (object) => {
     const camelCasedObject = {};
     Object.keys(object).forEach((arg) => {
         const camelCasedArg = arg.replace(/-(.)/g, ($1) => $1.toUpperCase()).replace(/-/g, '');
+        // @ts-expect-error This is very hard to make stricter than it already will be at the top level
         camelCasedObject[camelCasedArg] = object[arg];
     });
     return camelCasedObject;
 };
-
+const mime = new Mime(standardMimes, otherMimes).define({
+    // .tgz files don't have a MIME type defined, this fixes it
+    'application/gzip': ['tgz'],
+    // Default mime-type for .ts(x) files is video/mp2t. But in our usecases they're almost always TypeScript, which we want to treat as text
+    'text/typescript': ['ts', 'tsx', 'mts'],
+}, true);
 // Detect whether file is binary from its MIME type, or if not available, contents
 const getSourceFileFormat = (filePath, fileContent) => {
     // Try to detect the MIME type from the file path
-    // .tgz files don't have a MIME type defined, this fixes it
-    mime.define({ 'application/gzip': ['tgz'] }, true);
-    // Default mime-type for .ts(x) files is video/mp2t. But in our usecases they're almost always TypeScript, which we want to treat as text
-    mime.define({ 'text/typescript': ['ts', 'tsx', 'mts'] }, true);
-
     const contentType = mime.getType(filePath);
     if (contentType) {
-        const format = (
-            contentType.startsWith('text/')
+        const format = (contentType.startsWith('text/')
             || contentType.includes('javascript')
             || contentType.includes('json')
             || contentType.includes('xml')
@@ -338,15 +270,13 @@ const getSourceFileFormat = (filePath, fileContent) => {
             : SOURCE_FILE_FORMATS.BASE64;
         return format;
     }
-
     // If the MIME type detection failed, try to detect the file encoding from the file content
     const encoding = getEncoding(fileContent);
     return encoding === 'binary' ? SOURCE_FILE_FORMATS.BASE64 : SOURCE_FILE_FORMATS.TEXT;
 };
-
-const createSourceFiles = async (paths) => {
+export const createSourceFiles = async (paths, cwd) => {
     return paths.map((filePath) => {
-        const file = fs.readFileSync(filePath);
+        const file = readFileSync(join(cwd, filePath));
         const format = getSourceFileFormat(filePath, file);
         return {
             name: filePath,
@@ -357,138 +287,144 @@ const createSourceFiles = async (paths) => {
         };
     });
 };
-
 /**
  * Get actor local files, omit files defined in .gitignore and .git folder
  * All dot files(.file) and folders(.folder/) are included.
  */
-const getActorLocalFilePaths = () => globby(['*', '**/**'], {
+export const getActorLocalFilePaths = async (cwd) => globby(['*', '**/**'], {
     ignore: ['.git/**', 'apify_storage', 'node_modules', 'storage', 'crawlee_storage'],
     gitignore: true,
     dot: true,
+    cwd,
 });
-
 /**
  * Create zip file with all actor files specified with pathsToZip
- * @param zipName
- * @param pathsToZip
- * @return {Promise<void>}
  */
-const createActZip = async (zipName, pathsToZip) => {
+export const createActZip = async (zipName, pathsToZip, cwd) => {
     // NOTE: There can be a zip from a previous unfinished operation.
-    if (fs.existsSync(zipName)) await deleteFile(zipName);
-
-    const archive = archiver(zipName);
-
-    const archiveFilesPromises = [];
-    pathsToZip.forEach((globPath) => archiveFilesPromises.push(archive.glob(globPath)));
-    await Promise.all(archiveFilesPromises);
-
+    if (existsSync(zipName)) {
+        await deleteFile(zipName);
+    }
+    const writeStream = createWriteStream(zipName);
+    const archive = archiver('zip');
+    archive.pipe(writeStream);
+    pathsToZip.forEach((globPath) => archive.glob(globPath, { cwd }));
     await archive.finalize();
 };
-
 /**
  * Get actor input from local store
- * @return {{body: *, contentType: string}}
  */
-const getLocalInput = () => {
+export const getLocalInput = (cwd) => {
     const defaultLocalStorePath = getLocalKeyValueStorePath();
-    const files = fs.readdirSync(defaultLocalStorePath);
+    const files = readdirSync(join(cwd, defaultLocalStorePath));
     const inputName = files.find((file) => !!file.match(INPUT_FILE_REG_EXP));
-
     // No input file
-    if (!inputName) return;
-
-    const input = fs.readFileSync(path.join(defaultLocalStorePath, inputName));
+    if (!inputName)
+        return;
+    const input = readFileSync(join(cwd, defaultLocalStorePath, inputName));
     const contentType = mime.getType(inputName);
     return { body: input, contentType };
 };
-
-const purgeDefaultQueue = async () => {
+export const purgeDefaultQueue = async () => {
     const defaultQueuesPath = getLocalRequestQueuePath();
-    if (fs.existsSync(getLocalStorageDir()) && fs.existsSync(defaultQueuesPath)) {
+    if (existsSync(getLocalStorageDir()) && existsSync(defaultQueuesPath)) {
         await rimrafPromised(defaultQueuesPath);
     }
 };
-
-const purgeDefaultDataset = async () => {
+export const purgeDefaultDataset = async () => {
     const defaultDatasetPath = getLocalDatasetPath();
-    if (fs.existsSync(getLocalStorageDir()) && fs.existsSync(defaultDatasetPath)) {
+    if (existsSync(getLocalStorageDir()) && existsSync(defaultDatasetPath)) {
         await rimrafPromised(defaultDatasetPath);
     }
 };
-
-const purgeDefaultKeyValueStore = async () => {
+export const purgeDefaultKeyValueStore = async () => {
     const defaultKeyValueStorePath = getLocalKeyValueStorePath();
-    if (!fs.existsSync(getLocalStorageDir()) || !fs.existsSync(defaultKeyValueStorePath)) {
+    if (!existsSync(getLocalStorageDir()) || !existsSync(defaultKeyValueStorePath)) {
         return;
     }
-    const filesToDelete = fs.readdirSync(defaultKeyValueStorePath);
-
+    const filesToDelete = readdirSync(defaultKeyValueStorePath);
     const deletePromises = [];
     filesToDelete.forEach((file) => {
-        if (!file.match(INPUT_FILE_REG_EXP)) deletePromises.push(deleteFile(path.join(defaultKeyValueStorePath, file)));
+        if (!file.match(INPUT_FILE_REG_EXP)) {
+            deletePromises.push(deleteFile(join(defaultKeyValueStorePath, file)));
+        }
     });
-
     await Promise.all(deletePromises);
 };
-
-const outputJobLog = async (job, timeout) => {
+export const outputJobLog = async (job, timeout) => {
     const { id: logId, status } = job;
+    const apifyClient = new ApifyClient({ baseUrl: process.env.APIFY_CLIENT_BASE_URL });
     // In case job was already done just output log
-    if (ACT_JOB_TERMINAL_STATUSES.includes(status)) {
-        const apifyClient = new ApifyClient({ baseUrl: process.env.APIFY_CLIENT_BASE_URL });
+    if (ACTOR_JOB_TERMINAL_STATUSES.includes(status)) {
         const log = await apifyClient.log(logId).get();
         process.stdout.write(log);
+        return;
     }
-
     // In other case stream it to stdout
-    // TODO: Use apifyClient.log(logId).stream() instead of http request stream.
-    return new Promise((resolve, reject) => {
-        const req = https.get(`https://api.apify.com/v2/logs/${logId}?stream=1`);
-        let res;
-
-        req.on('response', (response) => {
-            res = response;
-            response.on('data', (chunk) => process.stdout.write(chunk.toString()));
-            response.on('error', (err) => {
-                reject(err);
-            });
-        });
-        req.on('error', (err) => {
-            reject(err);
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve) => {
+        const stream = await apifyClient.log(logId).stream();
+        if (!stream) {
+            resolve('no-logs');
+            return;
+        }
+        let nodeTimeout = null;
+        stream.on('data', (chunk) => {
+            process.stdout.write(chunk.toString());
         });
-        req.on('close', () => {
+        stream.once('end', () => {
             resolve('finished');
+            if (nodeTimeout) {
+                clearTimeout(nodeTimeout);
+            }
         });
-
         if (timeout) {
-            setTimeout(() => {
-                if (res) res.removeAllListeners();
-                if (req) {
-                    req.removeAllListeners();
-                    req.abort();
-                }
+            nodeTimeout = setTimeout(() => {
+                stream.destroy();
                 resolve('timeouts');
             }, timeout);
         }
     });
+    // return new Promise((resolve, reject) => {
+    //     const req = get(`https://api.apify.com/v2/logs/${logId}?stream=1`);
+    //     let res: IncomingMessage;
+    //     req.on('response', (response) => {
+    //         res = response;
+    //         response.on('data', (chunk) => process.stdout.write(chunk.toString()));
+    //         response.on('error', (err) => {
+    //             reject(err);
+    //         });
+    //     });
+    //     req.on('error', (err) => {
+    //         reject(err);
+    //     });
+    //     req.on('close', () => {
+    //         resolve('finished');
+    //     });
+    //     if (timeout) {
+    //         setTimeout(() => {
+    //             if (res) res.removeAllListeners();
+    //             if (req) {
+    //                 req.removeAllListeners();
+    //                 req.destroy();
+    //             }
+    //             resolve('timeouts');
+    //         }, timeout);
+    //     }
+    // });
 };
-
 /**
  * Returns npm command for current os
  * NOTE: For window we have to returns npm.cmd instead of npm, otherwise it doesn't work
  * @return {string}
  */
-const getNpmCmd = () => {
+export const getNpmCmd = () => {
     return /^win/.test(process.platform) ? 'npm.cmd' : 'npm';
 };
-
 /**
  * Returns true if apify storage is empty (expect INPUT.*)
- * @return {Promise<boolean>}
  */
-const checkIfStorageIsEmpty = async () => {
+export const checkIfStorageIsEmpty = async () => {
     const filesWithoutInput = await globby([
         `${getLocalStorageDir()}/**`,
         // Omit INPUT.* file
@@ -496,20 +432,10 @@ const checkIfStorageIsEmpty = async () => {
     ]);
     return filesWithoutInput.length === 0;
 };
-
-/**
- * Show help for command
- * NOTE: This is not nice, but I can not find other way..
- * @param command
- */
-const showHelpForCommand = (command) => {
-    execSync(`apify ${command} --help`, { stdio: [0, 1, 2] });
-};
-
 /**
  * Migration for deprecated structure of apify.json to latest.
- * @param localConfig
  */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const updateLocalConfigStructure = (localConfig) => {
     const updatedLocalConfig = {
         name: localConfig.name,
@@ -521,18 +447,18 @@ const updateLocalConfigStructure = (localConfig) => {
     if (localConfig.version.envVars && localConfig.version.envVars.length) {
         const env = {};
         localConfig.version.envVars.forEach((envVar) => {
-            if (envVar.name && envVar.value) env[envVar.name] = envVar.value;
+            if (envVar.name && envVar.value)
+                env[envVar.name] = envVar.value;
         });
         updatedLocalConfig.env = env;
     }
     return updatedLocalConfig;
 };
-
 /**
  * Validates actor name, if finds issue throws error.
  * @param actorName
  */
-const validateActorName = (actorName) => {
+export const validateActorName = (actorName) => {
     if (!ACTOR_NAME.REGEX.test(actorName)) {
         throw new Error('The Actor name must be a DNS hostname-friendly string (e.g. my-newest-actor).');
     }
@@ -543,148 +469,110 @@ const validateActorName = (actorName) => {
         throw new Error('The Actor name must be a maximum of 30 characters long.');
     }
 };
-
-const sanitizeActorName = (actorName) => {
+export const sanitizeActorName = (actorName) => {
     let sanitizedName = actorName
         .replaceAll(/[^a-zA-Z0-9-]/g, '-');
-
     if (sanitizedName.length < ACTOR_NAME.MIN_LENGTH) {
         sanitizedName = `${sanitizedName}-apify-actor`;
     }
-
     sanitizedName = sanitizedName.replaceAll(/^-+/g, '').replaceAll(/-+$/g, '');
-
     return sanitizedName.slice(0, ACTOR_NAME.MAX_LENGTH);
 };
-
-const getPythonCommand = (directory) => {
+export const getPythonCommand = (directory) => {
     const pythonVenvPath = /^win/.test(process.platform)
         ? 'Scripts/python.exe'
         : 'bin/python3';
-
     let fullPythonVenvPath;
     if (process.env.VIRTUAL_ENV) {
-        fullPythonVenvPath = path.join(process.env.VIRTUAL_ENV, pythonVenvPath);
-    } else {
-        fullPythonVenvPath = path.join(directory, '.venv', pythonVenvPath);
+        fullPythonVenvPath = join(process.env.VIRTUAL_ENV, pythonVenvPath);
+    }
+    else {
+        fullPythonVenvPath = join(directory, '.venv', pythonVenvPath);
     }
-
-    if (fs.existsSync(fullPythonVenvPath)) {
+    if (existsSync(fullPythonVenvPath)) {
         return fullPythonVenvPath;
     }
-
     return /^win/.test(process.platform)
         ? 'python'
         : 'python3';
 };
-
-const detectPythonVersion = (directory) => {
+export const detectPythonVersion = (directory) => {
     const pythonCommand = getPythonCommand(directory);
     try {
         const spawnResult = spawnSync(pythonCommand, ['-c', 'import platform; print(platform.python_version())'], { encoding: 'utf-8' });
         if (!spawnResult.error && spawnResult.stdout) {
             return spawnResult.stdout.trim();
         }
-    } catch {
+        return undefined;
+    }
+    catch {
         return undefined;
     }
 };
-
-const isPythonVersionSupported = (installedPythonVersion) => {
-    return semver.satisfies(installedPythonVersion, `^${MINIMUM_SUPPORTED_PYTHON_VERSION}`);
+export const isPythonVersionSupported = (installedPythonVersion) => {
+    return satisfies(installedPythonVersion, `^${MINIMUM_SUPPORTED_PYTHON_VERSION}`);
 };
-
-const detectNodeVersion = () => {
+export const detectNodeVersion = () => {
     try {
         const spawnResult = spawnSync('node', ['--version'], { encoding: 'utf-8' });
         if (!spawnResult.error && spawnResult.stdout) {
             return spawnResult.stdout.trim().replace(/^v/, '');
         }
-    } catch {
+        return undefined;
+    }
+    catch {
         return undefined;
     }
 };
-
-const isNodeVersionSupported = (installedNodeVersion) => {
+export const isNodeVersionSupported = (installedNodeVersion) => {
     // SUPPORTED_NODEJS_VERSION can be a version range,
     // we need to get the minimum supported version from that range to be able to compare them
-    const minimumSupportedNodeVersion = semver.minVersion(SUPPORTED_NODEJS_VERSION);
-    return semver.gte(installedNodeVersion, minimumSupportedNodeVersion);
+    const minimumSupportedNodeVersion = minVersion(SUPPORTED_NODEJS_VERSION);
+    return gte(installedNodeVersion, minimumSupportedNodeVersion);
 };
-
-const detectNpmVersion = () => {
+export const detectNpmVersion = () => {
     const npmCommand = getNpmCmd();
     try {
         const spawnResult = spawnSync(npmCommand, ['--version'], { encoding: 'utf-8' });
         if (!spawnResult.error && spawnResult.stdout) {
             return spawnResult.stdout.trim().replace(/^v/, '');
         }
-    } catch {
+        return undefined;
+    }
+    catch {
         return undefined;
     }
 };
-
-const detectLocalActorLanguage = () => {
-    const cwd = process.cwd();
-    const isActorInNode = fs.existsSync(path.join(cwd, 'package.json'));
-    const isActorInPython = fs.existsSync(path.join(cwd, 'src/__main__.py')) || ProjectAnalyzer.getProjectType(cwd) === PROJECT_TYPES.SCRAPY;
+export const detectLocalActorLanguage = (cwd) => {
+    const isActorInNode = existsSync(join(cwd, 'package.json'));
+    const isActorInPython = existsSync(join(cwd, 'src/__main__.py')) || ProjectAnalyzer.getProjectType(cwd) === PROJECT_TYPES.SCRAPY;
     const result = {};
     if (isActorInNode) {
         result.language = LANGUAGE.NODEJS;
         result.languageVersion = detectNodeVersion();
-    } else if (isActorInPython) {
+    }
+    else if (isActorInPython) {
         result.language = LANGUAGE.PYTHON;
         result.languageVersion = detectPythonVersion(cwd);
-    } else {
+    }
+    else {
         result.language = LANGUAGE.UNKNOWN;
     }
     return result;
 };
-
-const downloadAndUnzip = async ({ url, pathTo }) => {
+export const downloadAndUnzip = async ({ url, pathTo }) => {
     const zipStream = await httpsGet(url);
     const chunks = [];
     zipStream.on('data', (chunk) => chunks.push(chunk));
-    await promisify(finished)(zipStream);
+    await finished(zipStream);
     const zip = new AdmZip(Buffer.concat(chunks));
     zip.extractAllTo(pathTo, true);
 };
-
-module.exports = {
-    httpsGet,
-    getLoggedClientOrThrow,
-    getLocalConfig,
-    setLocalConfig,
-    setLocalEnv,
-    argsToCamelCase,
-    getLoggedClient,
-    createActZip,
-    getLocalUserInfo,
-    getLocalConfigOrThrow,
-    getLocalInput,
-    purgeDefaultQueue,
-    purgeDefaultDataset,
-    purgeDefaultKeyValueStore,
-    outputJobLog,
-    getLocalKeyValueStorePath,
-    getLocalDatasetPath,
-    getLocalRequestQueuePath,
-    getNpmCmd,
-    checkIfStorageIsEmpty,
-    getLocalStorageDir,
-    showHelpForCommand,
-    getActorLocalFilePaths,
-    createSourceFiles,
-    validateActorName,
-    getJsonFileContent,
-    getApifyClientOptions,
-    detectPythonVersion,
-    isPythonVersionSupported,
-    getPythonCommand,
-    detectNodeVersion,
-    isNodeVersionSupported,
-    detectNpmVersion,
-    detectLocalActorLanguage,
-    downloadAndUnzip,
-    sanitizeActorName,
+/**
+ * Ensures the Apify directory exists, as well as nested folders (for tests)
+ */
+export const ensureApifyDirectory = (file) => {
+    const path = dirname(file);
+    mkdirSync(path, { recursive: true });
 };
+//# sourceMappingURL=utils.js.map