@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

package/dist/src/command-line/reset/reset.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetHandler = resetHandler;
+const node_fs_1 = require("node:fs");
+const client_1 = require("../../daemon/client/client");
+const tmp_dir_1 = require("../../daemon/tmp-dir");
+const cache_directory_1 = require("../../utils/cache-directory");
+const output_1 = require("../../utils/output");
+const native_file_cache_location_1 = require("../../native/native-file-cache-location");
+const workspace_root_1 = require("../../utils/workspace-root");
+const client_2 = require("../../nx-cloud/utilities/client");
+const get_cloud_options_1 = require("../../nx-cloud/utilities/get-cloud-options");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const configuration_1 = require("../../config/configuration");
+const db_connection_1 = require("../../utils/db-connection");
+const update_manager_1 = require("../../nx-cloud/update-manager");
+// Wait at max 5 seconds before giving up on a failing operation.
+const INCREMENTAL_BACKOFF_MAX_DURATION = 5000;
+// If an operation fails, wait 100ms before first retry.
+const INCREMENTAL_BACKOFF_FIRST_DELAY = 100;
+async function resetHandler(args) {
+    let errors = [];
+    const all = args.onlyDaemon === undefined &&
+        args.onlyCache === undefined &&
+        args.onlyWorkspaceData === undefined;
+    const nxJson = (0, configuration_1.readNxJson)();
+    const cloudEnabled = (0, nx_cloud_utils_1.isNxCloudUsed)(nxJson);
+    const startupMessage = all
+        ? 'Resetting the Nx cache and stopping the daemon.'
+        : 'Resetting:';
+    const bodyLines = [];
+    if (!all) {
+        if (args.onlyDaemon) {
+            bodyLines.push('- Nx Daemon and its workspace data');
+        }
+        if (args.onlyCache) {
+            bodyLines.push('- Cache directory');
+        }
+        if (args.onlyWorkspaceData) {
+            bodyLines.push('- Workspace data directory');
+        }
+        if (args.onlyCloud && cloudEnabled) {
+            bodyLines.push('- Nx Cloud Client');
+        }
+    }
+    output_1.output.note({ title: startupMessage, bodyLines });
+    if (all || args.onlyDaemon) {
+        try {
+            await killDaemon();
+        }
+        catch (e) {
+            errors.push('Failed to stop the Nx Daemon.', e.toString());
+        }
+        try {
+            await cleanupDaemonWorkspaceData();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the daemon workspace data directory.', e.toString());
+        }
+    }
+    if (all || args.onlyCache) {
+        try {
+            await cleanupCacheEntries();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the cache directory.', e.toString());
+        }
+    }
+    if (all || args.onlyWorkspaceData) {
+        try {
+            await cleanupNativeFileCache();
+        }
+        catch {
+            // ignore, deleting the native file cache is not critical and can fail if another process is locking the file
+        }
+        try {
+            await cleanupWorkspaceData();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the workspace data directory.', e.toString());
+        }
+    }
+    if ((cloudEnabled && all) || args.onlyCloud) {
+        try {
+            await resetCloudClient();
+        }
+        catch (e) {
+            errors.push('Failed to clean up the Nx Cloud client.', e.toString());
+        }
+        try {
+            await removeInstalledNxCloudClient();
+        }
+        catch (e) {
+            errors.push('Failed to reset the Nx Cloud client.', e.toString());
+        }
+    }
+    if (errors.length > 0) {
+        output_1.output.error({
+            title: 'Failed to reset the Nx workspace.',
+            bodyLines: errors,
+        });
+        process.exit(1);
+    }
+    else {
+        output_1.output.success({
+            title: 'Successfully reset the Nx workspace.',
+        });
+    }
+}
+async function killDaemon() {
+    if (client_1.daemonClient.enabled()) {
+        return client_1.daemonClient.stop();
+    }
+}
+function cleanupDaemonWorkspaceData() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)(tmp_dir_1.DAEMON_DIR_FOR_CURRENT_WORKSPACE, {
+            recursive: true,
+            force: true,
+        });
+    });
+}
+async function resetCloudClient() {
+    // Remove nx cloud marker files. This helps if the use happens to run `nx-cloud start-ci-run` or
+    // similar commands on their local machine.
+    // `exit` would end the process here, before reset reports its result.
+    await (await (0, client_2.getCloudClient)((0, get_cloud_options_1.getCloudOptions)())).invoke('cleanup', false);
+}
+function removeInstalledNxCloudClient() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)((0, update_manager_1.getBundleInstallDefaultLocation)(), { recursive: true, force: true });
+    });
+}
+function cleanupCacheEntries() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        (0, node_fs_1.rmSync)(cache_directory_1.cacheDir, { recursive: true, force: true });
+        // `cacheDir` is the shared directory whenever sharing is available, so
+        // this is the checkout's own `.nx/cache`: still there from before the
+        // move, and still what a later run falls back to if `~/.nx` stops being
+        // reachable. Reset means both.
+        removeIfDistinct((0, cache_directory_1.cacheDirectoryForWorkspace)(workspace_root_1.workspaceRoot), cache_directory_1.cacheDir);
+    });
+}
+/** Skips the no-op when the two resolve to one directory. */
+function removeIfDistinct(dir, from) {
+    if (dir !== from) {
+        (0, node_fs_1.rmSync)(dir, { recursive: true, force: true });
+    }
+}
+function cleanupNativeFileCache() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        // Null when the native cache root is not a real directory we own, which
+        // would mean deleting through a path another user planted.
+        const cacheDir = (0, native_file_cache_location_1.getNativeFileCacheLocationToDelete)();
+        if (cacheDir) {
+            (0, node_fs_1.rmSync)(cacheDir, { recursive: true, force: true });
+        }
+    });
+}
+function cleanupWorkspaceData() {
+    return incrementalBackoff(INCREMENTAL_BACKOFF_FIRST_DELAY, INCREMENTAL_BACKOFF_MAX_DURATION, () => {
+        // Analytics opened the DB at startup; Windows cannot delete an open file.
+        (0, db_connection_1.removeDbConnections)();
+        (0, node_fs_1.rmSync)(cache_directory_1.workspaceDataDirectory, { recursive: true, force: true });
+        // Also clean wherever the DB actually lives, which is outside this
+        // checkout whenever the shared root is reachable. Resolved through the
+        // same decision the DB itself uses, so reset cannot delete a directory
+        // this process never wrote to -- a sandboxed agent that fell back to its
+        // own checkout, or a configured location, yields nothing extra.
+        removeIfDistinct((0, cache_directory_1.sharedDataDirectory)(workspace_root_1.workspaceRoot, 'workspace-data'), cache_directory_1.workspaceDataDirectory);
+    });
+}
+async function incrementalBackoff(ms, maxDuration, callback) {
+    try {
+        callback();
+    }
+    catch (e) {
+        if (ms < maxDuration) {
+            await sleep(ms);
+            await incrementalBackoff(ms * 2, maxDuration, callback);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/src/command-line/run/command-object.d.ts

@@ -0,0 +1,6 @@
+import { CommandModule } from 'yargs';
+export declare const yargsRunCommand: CommandModule;
+/**
+ * Handles the infix notation for running a target.
+ */
+export declare const yargsNxInfixCommand: CommandModule;

package/dist/src/command-line/run/command-object.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsNxInfixCommand = exports.yargsRunCommand = void 0;
+const yargs_1 = require("yargs");
+const handle_errors_1 = require("../../utils/handle-errors");
+const handle_import_1 = require("../../utils/handle-import");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsRunCommand = {
+    command: 'run [project][:target][:configuration] [_..]',
+    describe: `Run a target for a project
+    (e.g., nx run myapp:serve:production).
+
+    You can also use the infix notation to run a target:
+    (e.g., nx serve myapp --configuration=production)
+
+    You can skip the use of Nx cache by using the --skip-nx-cache option.`,
+    builder: (yargs) => (0, shared_options_1.withTuiOptions)((0, shared_options_1.withRunOneOptions)((0, shared_options_1.withBatch)(yargs))),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            await (0, handle_import_1.handleImport)('./run-one.js', __dirname).then((m) => m.runOne(process.cwd(), (0, shared_options_1.withOverrides)(args)));
+        });
+        process.exit(exitCode);
+    },
+};
+/**
+ * Handles the infix notation for running a target.
+ */
+exports.yargsNxInfixCommand = {
+    ...exports.yargsRunCommand,
+    command: '$0 <target> [project] [_..]',
+    describe: 'Run a target for a project.',
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose ?? process.env.NX_VERBOSE_LOGGING === 'true', async () => {
+            // Yargs parses <target> as 'undefined' if running just 'nx'
+            if (!args.target || args.target === 'undefined') {
+                (0, yargs_1.showHelp)();
+                process.exit(1);
+            }
+            return (await (0, handle_import_1.handleImport)('./run-one.js', __dirname)).runOne(process.cwd(), (0, shared_options_1.withOverrides)(args, 0));
+        });
+        process.exit(exitCode);
+    },
+};

package/dist/src/command-line/run/completion.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/command-line/run/completion.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const metadata_1 = require("../completion/metadata");
+const completion_providers_1 = require("../completion/completion-providers");
+(0, metadata_1.registerCompletion)('run', {
+    positionals: [{ complete: completion_providers_1.completeProjectTarget }],
+});

package/dist/src/command-line/run/executor-utils.d.ts

@@ -0,0 +1,12 @@
+import { ExecutorConfig } from '../../config/misc-interfaces';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+export declare function normalizeExecutorSchema(schema: Partial<ExecutorConfig['schema']>): ExecutorConfig['schema'];
+export declare function parseExecutor(executorString: string): [module: string, name: string];
+export declare function getExecutorInformation(nodeModule: string, executor: string, root: string, 
+/**
+ * A map of projects keyed by project name
+ */
+projects: Record<string, ProjectConfiguration>): ExecutorConfig & {
+    isNgCompat: boolean;
+    isNxExecutor: boolean;
+};

package/dist/src/command-line/run/executor-utils.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeExecutorSchema = normalizeExecutorSchema;
+exports.parseExecutor = parseExecutor;
+exports.getExecutorInformation = getExecutorInformation;
+const path_1 = require("path");
+const plugins_1 = require("../../project-graph/plugins");
+const fileutils_1 = require("../../utils/fileutils");
+const schema_utils_1 = require("../../config/schema-utils");
+const installation_directory_1 = require("../../utils/installation-directory");
+function normalizeExecutorSchema(schema) {
+    const version = (schema.version ??= 1);
+    return {
+        version,
+        outputCapture: (schema.outputCapture ?? version < 2) ? 'direct-nodejs' : 'pipe',
+        continuous: schema.continuous ?? false,
+        properties: !schema.properties || typeof schema.properties !== 'object'
+            ? {}
+            : schema.properties,
+        ...schema,
+    };
+}
+function cacheKey(nodeModule, executor, root) {
+    return `${root}:${nodeModule}:${executor}`;
+}
+function parseExecutor(executorString) {
+    return executorString.split(':');
+}
+const cachedExecutorInformation = {};
+function getExecutorInformation(nodeModule, executor, root, 
+/**
+ * A map of projects keyed by project name
+ */
+projects) {
+    try {
+        const key = cacheKey(nodeModule, executor, root);
+        if (cachedExecutorInformation[key])
+            return cachedExecutorInformation[key];
+        const { executorsFilePath, executorConfig, isNgCompat } = readExecutorJson(nodeModule, executor, root, projects);
+        const executorsDir = (0, path_1.dirname)(executorsFilePath);
+        const schemaPath = (0, schema_utils_1.resolveSchema)(executorConfig.schema, executorsDir, nodeModule, projects);
+        const schema = normalizeExecutorSchema((0, fileutils_1.readJsonFile)(schemaPath));
+        const implementationFactory = (0, schema_utils_1.getImplementationFactory)(executorConfig.implementation, executorsDir, nodeModule, projects);
+        const batchImplementationFactory = executorConfig.batchImplementation
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.batchImplementation, executorsDir, nodeModule, projects)
+            : null;
+        const hasherFactory = executorConfig.hasher
+            ? (0, schema_utils_1.getImplementationFactory)(executorConfig.hasher, executorsDir, nodeModule, projects)
+            : null;
+        const res = {
+            schema,
+            implementationFactory,
+            batchImplementationFactory,
+            preferBatch: executorConfig.preferBatch,
+            hasherFactory,
+            isNgCompat,
+            isNxExecutor: !isNgCompat,
+        };
+        cachedExecutorInformation[key] = res;
+        return res;
+    }
+    catch (e) {
+        throw new Error(`Unable to resolve ${nodeModule}:${executor}.\n${e.message}`);
+    }
+}
+function readExecutorJson(nodeModule, executor, root, projects, extraRequirePaths = []) {
+    const { json: packageJson, path: packageJsonPath } = (0, plugins_1.readPluginPackageJson)(nodeModule, projects, root
+        ? [
+            root,
+            __dirname,
+            process.cwd(),
+            ...(0, installation_directory_1.getNxRequirePaths)(),
+            ...extraRequirePaths,
+        ]
+        : [__dirname, process.cwd(), ...(0, installation_directory_1.getNxRequirePaths)(), ...extraRequirePaths]);
+    const executorsFile = packageJson.executors ?? packageJson.builders;
+    if (!executorsFile) {
+        throw new Error(`The "${nodeModule}" package does not support Nx executors.`);
+    }
+    const basePath = (0, path_1.dirname)(packageJsonPath);
+    const executorsFilePath = require.resolve((0, path_1.join)(basePath, executorsFile));
+    const executorsJson = (0, fileutils_1.readJsonFile)(executorsFilePath);
+    const executorConfig = executorsJson.executors?.[executor] || executorsJson.builders?.[executor];
+    if (!executorConfig) {
+        throw new Error(`Cannot find executor '${executor}' in ${executorsFilePath}.`);
+    }
+    if (typeof executorConfig === 'string') {
+        // Angular CLI can have a builder pointing to another package:builder
+        const [packageName, executorName] = executorConfig.split(':');
+        return readExecutorJson(packageName, executorName, root, projects, [
+            basePath,
+        ]);
+    }
+    const isNgCompat = !executorsJson.executors?.[executor];
+    return { executorsFilePath, executorConfig, isNgCompat };
+}

package/dist/src/command-line/run/run-one.d.ts

@@ -0,0 +1,17 @@
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { ProjectGraph } from '../../config/project-graph';
+import { TargetDependencyConfig } from '../../config/workspace-json-project-json';
+export declare function runOne(cwd: string, args: {
+    [k: string]: any;
+}, extraTargetDependencies?: Record<string, (TargetDependencyConfig | string)[]>, extraOptions?: {
+    excludeTaskDependencies: boolean;
+    loadDotEnvFiles: boolean;
+}): Promise<void>;
+export declare function parseRunOneOptions(cwd: string, parsedArgs: {
+    [k: string]: any;
+}, projectGraph: ProjectGraph, nxJson: NxJsonConfiguration): {
+    project: any;
+    target: any;
+    configuration: any;
+    parsedArgs: any;
+};

package/dist/src/command-line/run/run-one.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runOne = runOne;
+exports.parseRunOneOptions = parseRunOneOptions;
+const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
+const configuration_1 = require("../../config/configuration");
+const handle_import_1 = require("../../utils/handle-import");
+const project_graph_1 = require("../../project-graph/project-graph");
+const run_command_1 = require("../../tasks-runner/run-command");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const output_1 = require("../../utils/output");
+const split_target_1 = require("../../utils/split-target");
+const workspace_root_1 = require("../../utils/workspace-root");
+const graph_1 = require("../graph/graph");
+const connect_to_nx_cloud_1 = require("../nx-cloud/connect/connect-to-nx-cloud");
+async function runOne(cwd, args, extraTargetDependencies = {}, extraOptions = {
+    excludeTaskDependencies: args.excludeTaskDependencies,
+    loadDotEnvFiles: process.env.NX_LOAD_DOT_ENV_FILES !== 'false',
+}) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
+    const nxJson = (0, configuration_1.readNxJson)();
+    const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+    const opts = parseRunOneOptions(cwd, args, projectGraph, nxJson);
+    const { nxArgs, overrides } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)({
+        ...opts.parsedArgs,
+        configuration: opts.configuration,
+        targets: [opts.target],
+    }, 'run-one', { printWarnings: args.graph !== 'stdout' }, nxJson);
+    const { projects, projectName } = getProjects(projectGraph, opts.project);
+    if (nxArgs.help) {
+        await (await (0, handle_import_1.handleImport)('./run.js', __dirname)).printTargetRunHelp({
+            ...opts,
+            project: projectName,
+        }, workspace_root_1.workspaceRoot);
+        process.exit(0);
+    }
+    await (0, connect_to_nx_cloud_1.connectToNxCloudIfExplicitlyAsked)(nxArgs);
+    // --graph's file output draws this selection; the live graph builds its own.
+    const selectTasks = () => (0, run_command_1.selectTasksForProjects)(projectGraph, projects.map((p) => p.name), nxArgs, overrides, extraTargetDependencies, extraOptions.excludeTaskDependencies);
+    if (nxArgs.graph) {
+        const projectNames = projects.map((t) => t.name);
+        const file = (0, command_line_utils_1.readGraphFileFromGraphArg)(nxArgs);
+        return await (0, graph_1.generateGraph)({
+            watch: true,
+            open: true,
+            view: 'tasks',
+            targets: nxArgs.targets,
+            projects: projectNames,
+            file,
+            taskSelection: selectTasks,
+            configuration: nxArgs.configuration,
+        }, projectNames);
+    }
+    else {
+        const status = await (0, run_command_1.runCommand)(selectTasks(), projectGraph, { nxJson }, nxArgs, overrides, projectName, extraTargetDependencies, extraOptions);
+        await output_1.output.drain();
+        process.exit(status);
+    }
+}
+function getProjects(projectGraph, projectName) {
+    if (projectGraph.nodes[projectName]) {
+        return {
+            projectName: projectName,
+            projects: [projectGraph.nodes[projectName]],
+            projectsMap: {
+                [projectName]: projectGraph.nodes[projectName],
+            },
+        };
+    }
+    else {
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], projectGraph.nodes);
+        if (projects.length === 1) {
+            const projectName = projects[0];
+            const project = projectGraph.nodes[projectName];
+            return {
+                projectName,
+                projects: [project],
+                projectsMap: {
+                    [project.data.name]: project,
+                },
+            };
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched:`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            process.exit(1);
+        }
+    }
+    output_1.output.error({
+        title: `Cannot find project '${projectName}'`,
+    });
+    process.exit(1);
+}
+const targetAliases = {
+    b: 'build',
+    e: 'e2e',
+    l: 'lint',
+    s: 'serve',
+    t: 'test',
+};
+const PROJECT_TARGET_CONFIG = 'project:target:configuration';
+function parseRunOneOptions(cwd, parsedArgs, projectGraph, nxJson) {
+    const defaultProjectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(cwd, workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(projectGraph), nxJson);
+    let project;
+    let target;
+    let configuration;
+    if (typeof parsedArgs[PROJECT_TARGET_CONFIG] === 'string' &&
+        parsedArgs[PROJECT_TARGET_CONFIG].lastIndexOf(':') > 0) {
+        // run case
+        [project, target, configuration] = (0, split_target_1.splitTarget)(parsedArgs[PROJECT_TARGET_CONFIG], projectGraph, { currentProject: defaultProjectName });
+        // this is to account for "nx npmscript:dev"
+        if (project && !target && defaultProjectName) {
+            target = project;
+            project = defaultProjectName;
+        }
+    }
+    else if (parsedArgs.target) {
+        target = parsedArgs.target;
+    }
+    else if (typeof parsedArgs[PROJECT_TARGET_CONFIG] === 'string') {
+        // If project:target:configuration exists but has no colon, check if it's a project with run target
+        if (projectGraph.nodes[parsedArgs[PROJECT_TARGET_CONFIG]]?.data?.targets?.run) {
+            target = 'run';
+            project = parsedArgs[PROJECT_TARGET_CONFIG];
+        }
+        else {
+            target = parsedArgs[PROJECT_TARGET_CONFIG];
+        }
+    }
+    if (parsedArgs.project) {
+        project = parsedArgs.project;
+    }
+    if (!project && defaultProjectName) {
+        project = defaultProjectName;
+    }
+    if (!project || !target) {
+        throw new Error(`Both project and target have to be specified`);
+    }
+    if (targetAliases[target]) {
+        target = targetAliases[target];
+    }
+    if (parsedArgs.configuration) {
+        configuration = parsedArgs.configuration;
+    }
+    else if (parsedArgs.prod) {
+        configuration = 'production';
+    }
+    const res = { project, target, configuration, parsedArgs };
+    delete parsedArgs['c'];
+    delete parsedArgs[PROJECT_TARGET_CONFIG];
+    delete parsedArgs['configuration'];
+    delete parsedArgs['prod'];
+    delete parsedArgs['project'];
+    return res;
+}

package/dist/src/command-line/run/run.d.ts

@@ -0,0 +1,51 @@
+import { Schema } from '../../utils/params';
+import { ProjectsConfigurations } from '../../config/workspace-json-project-json';
+import { ExecutorContext } from '../../config/misc-interfaces';
+import { TaskGraph } from '../../config/task-graph';
+export interface Target {
+    project: string;
+    target: string;
+    configuration?: string;
+}
+export declare function printRunHelp(opts: {
+    project: string;
+    target: string;
+}, schema: Schema, plugin: {
+    plugin: string;
+    entity: string;
+}): void;
+export declare function validateProject(projects: ProjectsConfigurations, projectName: string): void;
+/**
+ * Loads and invokes executor.
+ *
+ * This is analogous to invoking executor from the terminal, with the exception
+ * that the params aren't parsed from the string, but instead provided parsed already.
+ *
+ * Apart from that, it works the same way:
+ *
+ * - it will load the workspace configuration
+ * - it will resolve the target
+ * - it will load the executor and the schema
+ * - it will load the options for the appropriate configuration
+ * - it will run the validations and will set the default
+ * - and, of course, it will invoke the executor
+ *
+ * Example:
+ *
+ * ```typescript
+ * for await (const s of await runExecutor({project: 'myproj', target: 'serve'}, {watch: true}, context)) {
+ *   // s.success
+ * }
+ * ```
+ *
+ * Note that the return value is a promise of an iterator, so you need to await before iterating over it.
+ */
+export declare function runExecutor<T extends {
+    success: boolean;
+}>(targetDescription: Target, overrides: {
+    [k: string]: any;
+}, context: ExecutorContext): Promise<AsyncIterableIterator<T>>;
+export declare function printTargetRunHelp(targetDescription: Target, root: string): Promise<number>;
+export declare function run(cwd: string, root: string, targetDescription: Target, overrides: {
+    [k: string]: any;
+}, isVerbose: boolean, taskGraph: TaskGraph): Promise<number>;