@nx/plugin 0.0.0-pr-22179-271588f

package/src/migrations/update-16-0-0/cli-in-schema-json.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateCliPropsForPlugins = void 0;
+const devkit_1 = require("@nx/devkit");
+const package_json_1 = require("nx/src/utils/package-json");
+const path_1 = require("path");
+function updateCliPropsForPlugins(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const project of projects.values()) {
+        if (tree.exists((0, devkit_1.joinPathFragments)(project.root, 'package.json'))) {
+            const packageJson = (0, devkit_1.readJson)(tree, (0, devkit_1.joinPathFragments)(project.root, 'package.json'));
+            const migrateConfig = (0, package_json_1.readNxMigrateConfig)(packageJson);
+            if (migrateConfig.migrations) {
+                const migrationsPath = (0, devkit_1.joinPathFragments)(project.root, migrateConfig.migrations);
+                if (tree.exists(migrationsPath)) {
+                    updateMigrationsJsonForPlugin(tree, migrationsPath);
+                }
+                else {
+                    devkit_1.output.warn({
+                        title: `Migrations file specified for ${packageJson.name} does not exist: ${migrationsPath}`,
+                        bodyLines: [
+                            'Please ensure that migrations that use the Angular Devkit are placed inside the `schematics` property, and migrations that use the Nx Devkit are placed inside the `generators` property.',
+                        ],
+                    });
+                }
+            }
+            if (packageJson.generators) {
+                const generatorsPath = (0, devkit_1.joinPathFragments)(project.root, packageJson.generators);
+                if (tree.exists(generatorsPath)) {
+                    removeCliFromGeneratorSchemaJsonFiles(tree, generatorsPath);
+                }
+                else {
+                    devkit_1.output.warn({
+                        title: `Generators file specified for ${packageJson.name} does not exist: ${generatorsPath}`,
+                        bodyLines: [
+                            "The `cli` property inside generator's `schema.json` files is no longer supported.",
+                        ],
+                    });
+                }
+            }
+            if (packageJson.executors) {
+                const executorsPath = (0, devkit_1.joinPathFragments)(project.root, packageJson.executors);
+                if (tree.exists(executorsPath)) {
+                    removeCliFromExecutorSchemaJsonFiles(tree, executorsPath);
+                }
+                else {
+                    devkit_1.output.warn({
+                        title: `Executors file specified for ${packageJson.name} does not exist: ${executorsPath}`,
+                        bodyLines: [
+                            "The `cli` property inside executor's `schema.json` files is no longer supported.",
+                        ],
+                    });
+                }
+            }
+            if (packageJson.builders) {
+                const buildersPath = (0, devkit_1.joinPathFragments)(project.root, packageJson.builders);
+                if (tree.exists(buildersPath)) {
+                    removeCliFromExecutorSchemaJsonFiles(tree, buildersPath);
+                }
+                else {
+                    devkit_1.output.warn({
+                        title: `Builders file specified for ${packageJson.name} does not exist: ${buildersPath}`,
+                        bodyLines: [
+                            "The `cli` property inside builder's `schema.json` files is no longer supported.",
+                        ],
+                    });
+                }
+            }
+            if (packageJson.schematics) {
+                const schematicsPath = (0, devkit_1.joinPathFragments)(project.root, packageJson.schematics);
+                if (tree.exists(schematicsPath)) {
+                    removeCliFromGeneratorSchemaJsonFiles(tree, schematicsPath);
+                }
+                else {
+                    devkit_1.output.warn({
+                        title: `Schematics file specified for ${packageJson.name} does not exist: ${schematicsPath}`,
+                        bodyLines: [
+                            "The `cli` property inside schematic's `schema.json` files is no longer supported.",
+                        ],
+                    });
+                }
+            }
+        }
+    }
+}
+exports.updateCliPropsForPlugins = updateCliPropsForPlugins;
+function removeCliFromExecutorSchemaJsonFiles(tree, collectionPath) {
+    const collection = (0, devkit_1.readJson)(tree, collectionPath);
+    for (const [name, entry] of Object.entries(collection.executors ?? {}).concat(Object.entries(collection.builders ?? {}))) {
+        deleteCliPropFromSchemaFile(collectionPath, entry, tree);
+    }
+}
+function removeCliFromGeneratorSchemaJsonFiles(tree, collectionPath) {
+    const collection = (0, devkit_1.readJson)(tree, collectionPath);
+    for (const [name, entry] of Object.entries(collection.generators ?? {}).concat(Object.entries(collection.schematics ?? {}))) {
+        deleteCliPropFromSchemaFile(collectionPath, entry, tree);
+    }
+}
+function updateMigrationsJsonForPlugin(tree, collectionPath) {
+    (0, devkit_1.updateJson)(tree, collectionPath, (json) => {
+        for (const migration in json.generators ?? {}) {
+            if (!(json.generators[migration].cli === 'nx')) {
+                json.schematics ??= {};
+                json.schematics[migration] = json.generators[migration];
+                delete json.generators[migration];
+            }
+        }
+        for (const migration in json.schematics ?? {}) {
+            if (json.schematics[migration].cli === 'nx') {
+                json.generators ??= {};
+                json.generators[migration] = json.schematics[migration];
+                delete json.schematics[migration];
+            }
+        }
+        return json;
+    });
+}
+exports.default = updateCliPropsForPlugins;
+function deleteCliPropFromSchemaFile(collectionPath, entry, tree) {
+    if (!entry.schema) {
+        return;
+    }
+    const schemaPath = (0, devkit_1.joinPathFragments)((0, path_1.dirname)(collectionPath), entry.schema);
+    if (tree.exists(schemaPath)) {
+        (0, devkit_1.updateJson)(tree, schemaPath, (json) => {
+            if (json.cli) {
+                delete json.cli;
+            }
+            return json;
+        });
+    }
+    else {
+        console.warn(`Could not find schema file ${schemaPath}`);
+    }
+}

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replacePackage(tree: Tree): Promise<void>;

package/src/migrations/update-16-0-0-add-nx-packages/update-16-0-0-add-nx-packages.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const replace_package_1 = require("@nx/devkit/src/utils/replace-package");
+async function replacePackage(tree) {
+    await (0, replace_package_1.replaceNrwlPackageWithNxPackage)(tree, '@nrwl/nx-plugin', '@nx/plugin');
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replacePackage;

package/src/migrations/update-16-2-0/replace-e2e-executor.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export default function replaceE2EExecutor(tree: Tree): Promise<void>;

package/src/migrations/update-16-2-0/replace-e2e-executor.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const devkit_1 = require("@nx/devkit");
+const executor_options_utils_1 = require("@nx/devkit/src/generators/executor-options-utils");
+async function replaceE2EExecutor(tree) {
+    const projects = (0, devkit_1.getProjects)(tree);
+    for (const executor of ['@nx/plugin:e2e', '@nrwl/nx-plugin:e2e']) {
+        (0, executor_options_utils_1.forEachExecutorOptions)(tree, executor, (options, project, target, configuration) => {
+            const projectConfiguration = projects.get(project);
+            const config = {
+                ...options,
+                target: undefined,
+                runInBand: true,
+            };
+            if (configuration) {
+                projectConfiguration.targets[target].configurations[configuration] =
+                    config;
+            }
+            else {
+                projectConfiguration.targets[target].dependsOn = [
+                    ...(projectConfiguration.targets[target].dependsOn ?? []),
+                    options.target,
+                ];
+                projectConfiguration.targets[target].executor = '@nx/jest:jest';
+                projectConfiguration.targets[target].options = config;
+            }
+            (0, devkit_1.updateProjectConfiguration)(tree, project, projectConfiguration);
+        });
+    }
+    await (0, devkit_1.formatFiles)(tree);
+}
+exports.default = replaceE2EExecutor;

package/src/utils/has-generator.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function hasGenerator(tree: Tree, projectName: string, generatorName: string): boolean;

package/src/utils/has-generator.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasGenerator = void 0;
+const devkit_1 = require("@nx/devkit");
+function hasGenerator(tree, projectName, generatorName) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const packageJson = (0, devkit_1.readJson)(tree, (0, devkit_1.joinPathFragments)(project.root, 'package.json'));
+    if (!packageJson.generators && !packageJson.schematics) {
+        return false;
+    }
+    const generatorsPath = (0, devkit_1.joinPathFragments)(project.root, packageJson.generators ?? packageJson.schematics);
+    const generatorsJson = (0, devkit_1.readJson)(tree, generatorsPath);
+    return ((generatorsJson.generators?.[generatorName] ??
+        generatorsJson.schematics?.[generatorName]) !== undefined);
+}
+exports.hasGenerator = hasGenerator;

package/src/utils/testing-utils/async-commands.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+/**
+ * Run a command asynchronously inside the e2e directory.
+ *
+ * @param command
+ * @param opts
+ */
+export declare function runCommandAsync(command: string, opts?: {
+    silenceError?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;
+/**
+ * Run a nx command asynchronously inside the e2e directory
+ * @param command
+ * @param opts
+ */
+export declare function runNxCommandAsync(command: string, opts?: {
+    silenceError?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): Promise<{
+    stdout: string;
+    stderr: string;
+}>;

package/src/utils/testing-utils/async-commands.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runNxCommandAsync = exports.runCommandAsync = void 0;
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("./utils");
+/**
+ * Run a command asynchronously inside the e2e directory.
+ *
+ * @param command
+ * @param opts
+ */
+function runCommandAsync(command, opts = {
+    silenceError: false,
+}) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, {
+            cwd: opts.cwd ?? (0, paths_1.tmpProjPath)(),
+            env: { ...process.env, ...opts.env },
+        }, (err, stdout, stderr) => {
+            if (!opts.silenceError && err) {
+                reject(err);
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+exports.runCommandAsync = runCommandAsync;
+/**
+ * Run a nx command asynchronously inside the e2e directory
+ * @param command
+ * @param opts
+ */
+function runNxCommandAsync(command, opts = {
+    silenceError: false,
+}) {
+    const cwd = opts.cwd ?? (0, paths_1.tmpProjPath)();
+    if ((0, utils_1.fileExists)((0, paths_1.tmpProjPath)('package.json'))) {
+        const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(cwd));
+        return runCommandAsync(`${pmc.exec} nx ${command}`, opts);
+    }
+    else if (process.platform === 'win32') {
+        return runCommandAsync(`./nx.bat %${command}`, opts);
+    }
+    else {
+        return runCommandAsync(`./nx %${command}`, opts);
+    }
+}
+exports.runNxCommandAsync = runNxCommandAsync;

package/src/utils/testing-utils/commands.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" />
+/**
+ * Run a nx command inside the e2e directory
+ * @param command
+ * @param opts
+ *
+ * @see tmpProjPath
+ */
+export declare function runNxCommand(command?: string, opts?: {
+    silenceError?: boolean;
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): string;
+export declare function runCommand(command: string, opts: {
+    env?: NodeJS.ProcessEnv;
+    cwd?: string;
+}): string;

package/src/utils/testing-utils/commands.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = exports.runNxCommand = void 0;
+const child_process_1 = require("child_process");
+const paths_1 = require("./paths");
+const devkit_1 = require("@nx/devkit");
+const utils_1 = require("./utils");
+/**
+ * Run a nx command inside the e2e directory
+ * @param command
+ * @param opts
+ *
+ * @see tmpProjPath
+ */
+function runNxCommand(command, opts = {
+    silenceError: false,
+}) {
+    function _runNxCommand(c) {
+        const cwd = opts.cwd ?? (0, paths_1.tmpProjPath)();
+        const execSyncOptions = {
+            cwd,
+            env: { ...process.env, ...opts.env },
+        };
+        if ((0, utils_1.fileExists)((0, paths_1.tmpProjPath)('package.json'))) {
+            const pmc = (0, devkit_1.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(cwd));
+            return (0, child_process_1.execSync)(`${pmc.exec} nx ${command}`, execSyncOptions);
+        }
+        else if (process.platform === 'win32') {
+            return (0, child_process_1.execSync)(`./nx.bat %${command}`, execSyncOptions);
+        }
+        else {
+            return (0, child_process_1.execSync)(`./nx %${command}`, execSyncOptions);
+        }
+    }
+    try {
+        return _runNxCommand(command)
+            .toString()
+            .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+    }
+    catch (e) {
+        if (opts.silenceError) {
+            return e.stdout.toString();
+        }
+        else {
+            console.log(e.stdout.toString(), e.stderr.toString());
+            throw e;
+        }
+    }
+}
+exports.runNxCommand = runNxCommand;
+function runCommand(command, opts) {
+    try {
+        return (0, child_process_1.execSync)(command, {
+            cwd: opts.cwd ?? (0, paths_1.tmpProjPath)(),
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ...opts?.env },
+        }).toString();
+    }
+    catch (e) {
+        return e.stdout.toString() + e.stderr.toString();
+    }
+}
+exports.runCommand = runCommand;

package/src/utils/testing-utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './async-commands';
+export * from './commands';
+export * from './paths';
+export * from './nx-project';
+export * from './utils';

package/src/utils/testing-utils/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./async-commands"), exports);
+tslib_1.__exportStar(require("./commands"), exports);
+tslib_1.__exportStar(require("./paths"), exports);
+tslib_1.__exportStar(require("./nx-project"), exports);
+tslib_1.__exportStar(require("./utils"), exports);

package/src/utils/testing-utils/nx-project.d.ts

@@ -0,0 +1,25 @@
+export declare function patchPackageJsonForPlugin(npmPackageName: string, distPath: string): void;
+/**
+ * Generate a unique name for running CLI commands
+ * @param prefix
+ *
+ * @returns `'<prefix><random number>'`
+ */
+export declare function uniq(prefix: string): string;
+/**
+ * Run the appropriate package manager install command in the e2e directory
+ * @param silent silent output from the install
+ */
+export declare function runPackageManagerInstall(silent?: boolean): string;
+/**
+ * Creates a new nx project in the e2e directory
+ *
+ * @param npmPackageName package name to test
+ * @param pluginDistPath dist path where the plugin was outputted to
+ */
+export declare function newNxProject(npmPackageName: string, pluginDistPath: string): void;
+/**
+ * Ensures that a project has been setup in the e2e directory
+ * It will also copy `@nx` packages to the e2e directory
+ */
+export declare function ensureNxProject(npmPackageName?: string, pluginDistPath?: string): void;

package/src/utils/testing-utils/nx-project.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureNxProject = exports.newNxProject = exports.runPackageManagerInstall = exports.uniq = exports.patchPackageJsonForPlugin = void 0;
+const devkit_1 = require("@nx/devkit");
+const devkit_2 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const paths_1 = require("./paths");
+const utils_1 = require("./utils");
+function runNxNewCommand(args, silent) {
+    const localTmpDir = (0, path_1.dirname)((0, paths_1.tmpProjPath)());
+    return (0, child_process_1.execSync)(`node ${require.resolve('nx')} new proj --nx-workspace-root=${localTmpDir} --no-interactive --skip-install --collection=@nx/workspace --npmScope=proj --preset=apps ${args || ''}`, {
+        cwd: localTmpDir,
+        ...(silent && false ? { stdio: ['ignore', 'ignore', 'ignore'] } : {}),
+    });
+}
+function patchPackageJsonForPlugin(npmPackageName, distPath) {
+    const path = (0, paths_1.tmpProjPath)('package.json');
+    const json = (0, devkit_2.readJsonFile)(path);
+    json.devDependencies[npmPackageName] = `file:${devkit_1.workspaceRoot}/${distPath}`;
+    (0, devkit_2.writeJsonFile)(path, json);
+}
+exports.patchPackageJsonForPlugin = patchPackageJsonForPlugin;
+/**
+ * Generate a unique name for running CLI commands
+ * @param prefix
+ *
+ * @returns `'<prefix><random number>'`
+ */
+function uniq(prefix) {
+    return `${prefix}${Math.floor(Math.random() * 10000000)}`;
+}
+exports.uniq = uniq;
+/**
+ * Run the appropriate package manager install command in the e2e directory
+ * @param silent silent output from the install
+ */
+function runPackageManagerInstall(silent = true) {
+    const cwd = (0, paths_1.tmpProjPath)();
+    const pmc = (0, devkit_2.getPackageManagerCommand)((0, devkit_1.detectPackageManager)(cwd));
+    const install = (0, child_process_1.execSync)(pmc.install, {
+        cwd,
+        ...(silent ? { stdio: ['ignore', 'ignore', 'ignore'] } : {}),
+    });
+    return install ? install.toString() : '';
+}
+exports.runPackageManagerInstall = runPackageManagerInstall;
+/**
+ * Creates a new nx project in the e2e directory
+ *
+ * @param npmPackageName package name to test
+ * @param pluginDistPath dist path where the plugin was outputted to
+ */
+function newNxProject(npmPackageName, pluginDistPath) {
+    (0, utils_1.cleanup)();
+    runNxNewCommand('', true);
+    patchPackageJsonForPlugin(npmPackageName, pluginDistPath);
+    runPackageManagerInstall();
+}
+exports.newNxProject = newNxProject;
+/**
+ * Ensures that a project has been setup in the e2e directory
+ * It will also copy `@nx` packages to the e2e directory
+ */
+function ensureNxProject(npmPackageName, pluginDistPath) {
+    (0, fs_extra_1.ensureDirSync)((0, paths_1.tmpProjPath)());
+    newNxProject(npmPackageName, pluginDistPath);
+}
+exports.ensureNxProject = ensureNxProject;

package/src/utils/testing-utils/paths.d.ts

@@ -0,0 +1,15 @@
+export declare function tmpFolder(): string;
+/**
+ * The directory where the e2e workspace resides in.
+ *
+ * @param path path within the e2e directory
+ * @returns `'${process.cwd()}/tmp/nx-e2e/proj/<path>'`
+ */
+export declare function tmpProjPath(path?: string): string;
+/**
+ * The workspace backup directory. This is used for caching of the creation of the workspace.
+ *
+ * @param path path within the e2e directory
+ * @returns `'${process.cwd()}/tmp/nx-e2e/proj-backup/<path>'`
+ */
+export declare function tmpBackupProjPath(path?: string): string;

package/src/utils/testing-utils/paths.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tmpBackupProjPath = exports.tmpProjPath = exports.tmpFolder = void 0;
+const devkit_1 = require("@nx/devkit");
+function tmpFolder() {
+    return `${devkit_1.workspaceRoot}/tmp`;
+}
+exports.tmpFolder = tmpFolder;
+/**
+ * The directory where the e2e workspace resides in.
+ *
+ * @param path path within the e2e directory
+ * @returns `'${process.cwd()}/tmp/nx-e2e/proj/<path>'`
+ */
+function tmpProjPath(path) {
+    return path
+        ? `${tmpFolder()}/nx-e2e/proj/${path}`
+        : `${tmpFolder()}/nx-e2e/proj`;
+}
+exports.tmpProjPath = tmpProjPath;
+/**
+ * The workspace backup directory. This is used for caching of the creation of the workspace.
+ *
+ * @param path path within the e2e directory
+ * @returns `'${process.cwd()}/tmp/nx-e2e/proj-backup/<path>'`
+ */
+function tmpBackupProjPath(path) {
+    return path
+        ? `${devkit_1.workspaceRoot}/tmp/nx-e2e/proj-backup/${path}`
+        : `${devkit_1.workspaceRoot}/tmp/nx-e2e/proj-backup`;
+}
+exports.tmpBackupProjPath = tmpBackupProjPath;

package/src/utils/testing-utils/utils.d.ts

@@ -0,0 +1,80 @@
+import type { JsonParseOptions } from '@nx/devkit';
+import { directoryExists, fileExists } from 'nx/src/utils/fileutils';
+export { directoryExists, fileExists };
+/**
+ * Copies module folders from the working directory to the e2e directory
+ * @param modules a list of module names or scopes to copy
+ */
+export declare function copyNodeModules(modules: string[]): void;
+/**
+ * Assert test output from a asynchronous CLI command.
+ *
+ * @param output Output from an asynchronous command
+ */
+export declare function expectTestsPass(output: {
+    stdout: string;
+    stderr: string;
+}): void;
+/**
+ * Update a file's content in the e2e directory.
+ *
+ * If the `content` param is a callback, it will provide the original file content as an argument.
+ *
+ * @param file Path of the file in the e2e directory
+ * @param content Content to replace the original content with
+ */
+export declare function updateFile(file: string, content: string | ((originalFileContent: string) => string)): void;
+/**
+ * Rename a file or directory within the e2e directory.
+ * @param path Original path
+ * @param newPath New path
+ */
+export declare function renameFile(path: string, newPath: string): void;
+/**
+ * Check if the file or directory exists.
+ *
+ * If a path starts with `/` or `C:/`, it will check it as absolute. Otherwise it will check within the e2e directory.
+ *
+ * @param expectedPaths Files or directories to check
+ * @usage `checkFileExists('file1', 'file2', '/var/user/file')`
+ */
+export declare function checkFilesExist(...expectedPaths: string[]): void;
+/**
+ * Get a list of all files within a directory.
+ * @param dirName Directory name within the e2e directory.
+ */
+export declare function listFiles(dirName: string): string[];
+/**
+ * Read a JSON file.
+ * @param path Path to the JSON file. Absolute or relative to the e2e directory.
+ * @param options JSON parse options
+ */
+export declare function readJson<T extends object = any>(path: string, options?: JsonParseOptions): T;
+/**
+ * Read a file.
+ * @param path Path to the file. Absolute or relative to the e2e directory.
+ */
+export declare function readFile(path: string): string;
+/**
+ * Deletes the e2e directory
+ */
+export declare function cleanup(): void;
+/**
+ * Remove the dist folder from the e2e directory
+ */
+export declare function rmDist(): void;
+export declare function removeTmpProject(project: string): void;
+/**
+ * Get the currend `cwd` in the process
+ */
+export declare function getCwd(): string;
+/**
+ * Check if a file or directory exists.
+ * @param path Path to file or directory
+ */
+export declare function exists(path: string): boolean;
+/**
+ * Get the size of a file on disk
+ * @param filePath Path to the file
+ */
+export declare function getSize(filePath: string): number;