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

package/dist/src/daemon/server/handle-hash-tasks.d.ts

@@ -1,12 +0,0 @@
-import { Task, TaskGraph } from '../../config/task-graph';
-export declare function handleHashTasks(payload: {
-    runnerOptions: any;
-    tasks: Task[];
-    taskGraph: TaskGraph;
-    perTaskEnvs: Record<string, NodeJS.ProcessEnv>;
-    cwd: string;
-    collectInputs?: boolean;
-}): Promise<{
-    response: import("../../hasher/task-hasher").Hash[];
-    description: string;
-}>;

package/dist/src/daemon/server/handle-hash-tasks.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleHashTasks = handleHashTasks;
-const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
-const task_hasher_1 = require("../../hasher/task-hasher");
-const configuration_1 = require("../../config/configuration");
-/**
- * We use this not to recreated hasher for every hash operation
- * TaskHasher has a cache inside, so keeping it around results in faster performance
- */
-let storedProjectGraph = null;
-let storedHasher = null;
-async function handleHashTasks(payload) {
-    const { error, projectGraph, rustReferences } = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)();
-    if (error) {
-        throw error;
-    }
-    const nxJson = (0, configuration_1.readNxJson)();
-    if (projectGraph !== storedProjectGraph) {
-        storedProjectGraph = projectGraph;
-        storedHasher = new task_hasher_1.InProcessTaskHasher(projectGraph, nxJson, rustReferences, payload.runnerOptions);
-    }
-    const response = await storedHasher.hashTasks(payload.tasks, payload.taskGraph, payload.perTaskEnvs, payload.cwd, payload.collectInputs);
-    return {
-        response,
-        description: 'handleHashTasks',
-    };
-}

package/dist/src/daemon/server/handle-nx-console.d.ts

@@ -1,3 +0,0 @@
-import type { HandlerResult } from './server';
-export declare function handleGetNxConsoleStatus(): Promise<HandlerResult>;
-export declare function handleSetNxConsolePreferenceAndInstall(preference: boolean): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-nx-console.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleGetNxConsoleStatus = handleGetNxConsoleStatus;
-exports.handleSetNxConsolePreferenceAndInstall = handleSetNxConsolePreferenceAndInstall;
-const nx_console_operations_1 = require("./nx-console-operations");
-// Module-level state for caching
-let cachedShouldPrompt = null;
-let isComputing = false;
-async function handleGetNxConsoleStatus() {
-    // Return cached result if available
-    if (cachedShouldPrompt !== null) {
-        const response = {
-            shouldPrompt: cachedShouldPrompt,
-        };
-        return {
-            response,
-            description: 'handleGetNxConsoleStatus',
-        };
-    }
-    // Kick off background computation if not already running
-    if (!isComputing) {
-        isComputing = true;
-        (0, nx_console_operations_1.getNxConsoleStatus)()
-            .then((result) => {
-            cachedShouldPrompt = result;
-            isComputing = false;
-        })
-            .catch(() => {
-            cachedShouldPrompt = null;
-            isComputing = false;
-        });
-    }
-    // Return false for shouldPrompt if cache not ready (main process will noop)
-    const response = {
-        shouldPrompt: false,
-    };
-    return {
-        response,
-        description: 'handleGetNxConsoleStatus',
-    };
-}
-async function handleSetNxConsolePreferenceAndInstall(preference) {
-    // Immediately update cache - we know the answer now!
-    // User answered the prompt, so we won't prompt again
-    cachedShouldPrompt = false;
-    const result = await (0, nx_console_operations_1.handleNxConsolePreferenceAndInstall)({ preference });
-    const response = {
-        installed: result.installed,
-    };
-    return {
-        response,
-        description: 'handleSetNxConsolePreferenceAndInstall',
-    };
-}

package/dist/src/daemon/server/handle-nx-workspace-files.d.ts

@@ -1,2 +0,0 @@
-import { HandlerResult } from './server';
-export declare function handleNxWorkspaceFiles(projectRootMap: Record<string, string>): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-nx-workspace-files.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleNxWorkspaceFiles = handleNxWorkspaceFiles;
-const workspace_context_1 = require("../../utils/workspace-context");
-const workspace_root_1 = require("../../utils/workspace-root");
-async function handleNxWorkspaceFiles(projectRootMap) {
-    const files = await (0, workspace_context_1.getNxWorkspaceFilesFromContext)(workspace_root_1.workspaceRoot, projectRootMap);
-    return {
-        response: files,
-        description: 'handleNxWorkspaceFiles',
-    };
-}

package/dist/src/daemon/server/handle-outputs-changes.d.ts

@@ -1,10 +0,0 @@
-import type { FileWatcherCallback } from './watcher';
-/**
- * The error a native outputs watcher failure delivered, if one has. Such an
- * error is terminal (the native watch loop exits after delivering it), so the
- * gitignored dotenv edits only that watcher reports stop arriving and a warm
- * graph would go stale silently. The server fails requests closed on it, like
- * a workspace watcher error.
- */
-export declare function getOutputsWatcherTerminalError(): Error | undefined;
-export declare const handleOutputsChanges: FileWatcherCallback;

package/dist/src/daemon/server/handle-outputs-changes.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleOutputsChanges = void 0;
-exports.getOutputsWatcherTerminalError = getOutputsWatcherTerminalError;
-const logger_1 = require("../logger");
-const dotenv_graph_changes_1 = require("./dotenv-graph-changes");
-const outputs_tracking_1 = require("./outputs-tracking");
-const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
-let outputsWatcherError;
-let outputsWatcherTerminalError;
-/**
- * The error a native outputs watcher failure delivered, if one has. Such an
- * error is terminal (the native watch loop exits after delivering it), so the
- * gitignored dotenv edits only that watcher reports stop arriving and a warm
- * graph would go stale silently. The server fails requests closed on it, like
- * a workspace watcher error.
- */
-function getOutputsWatcherTerminalError() {
-    return outputsWatcherTerminalError;
-}
-const handleOutputsChanges = async (err, changeEvents) => {
-    try {
-        if (err || !changeEvents || !changeEvents.length) {
-            let error = typeof err === 'string' ? new Error(err) : err;
-            logger_1.serverLogger.watcherLog('Unexpected outputs watcher error', error.message);
-            console.error(error);
-            outputsWatcherError = error;
-            (0, outputs_tracking_1.disableOutputsTracking)();
-            if (err) {
-                // A native error is terminal: the watch loop has exited, so the
-                // gitignored dotenv edits only this watcher reports stop arriving and
-                // the graph invalidation below can never run again. Fail requests
-                // closed like a workspace watcher error rather than serving a graph
-                // that silently goes stale. The original error is preserved so an
-                // inotify_add_watch failure still makes the client disable the daemon
-                // and rebuild without it.
-                outputsWatcherTerminalError = error;
-            }
-            return;
-        }
-        // A dotenv change that a task chain loads must refresh the graph so
-        // createNodes re-resolves config reading process.env. This runs above the
-        // outputsWatcherError guard: the two concerns are independent, and a
-        // disabled outputs tracker must not leave the graph stale on a dotenv edit.
-        // A change to a file the workspace watcher tracks already schedules a
-        // recomputation that reads the new content; invalidating for it here too
-        // would discard that recomputation at commit and force a second one. It is
-        // queued instead of dropped: the two watchers deliver independently, so a
-        // computation already in flight may have read the file before the edit,
-        // and only the pre-serve replay can prove that. The committed file map
-        // approximates what the watcher tracks: a file it does not know is either
-        // gitignored (never reaches the workspace watcher, so it needs the
-        // invalidation) or created since the last recompute (the watcher handles
-        // it; the extra invalidation is fail-safe). Its own try/catch so a fault
-        // here cannot trip the outputs-tracking kill switch below, which belongs
-        // to an unrelated subsystem, and it fails safe by invalidating: a stale
-        // graph on a dotenv edit is the bug this prevents.
-        try {
-            const { invalidating, unclassified } = (0, dotenv_graph_changes_1.classifyDotEnvChanges)(changeEvents, project_graph_incremental_recomputation_1.currentProjectGraph);
-            const generation = (0, project_graph_incremental_recomputation_1.getRecomputationGeneration)();
-            (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(unclassified.map((event) => event.path), generation);
-            const knownInvalidating = invalidating.filter((path) => (0, project_graph_incremental_recomputation_1.isKnownWorkspaceFile)(path));
-            (0, dotenv_graph_changes_1.queuePendingDotEnvEvents)(knownInvalidating, generation);
-            if (knownInvalidating.length < invalidating.length) {
-                (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
-            }
-        }
-        catch (e) {
-            logger_1.serverLogger.watcherLog('Failed to evaluate dotenv changes for graph invalidation; invalidating the graph cache to be safe', e instanceof Error ? e.message : String(e));
-            console.error(e);
-            (0, project_graph_incremental_recomputation_1.invalidateGraphCache)();
-        }
-        if (outputsWatcherError) {
-            return;
-        }
-        logger_1.serverLogger.watcherLog('Processing file changes in outputs');
-        (0, outputs_tracking_1.processFileChangesInOutputs)(changeEvents);
-    }
-    catch (err) {
-        logger_1.serverLogger.watcherLog(`Unexpected outputs watcher error`, err.message);
-        console.error(err);
-        outputsWatcherError = err;
-        (0, outputs_tracking_1.disableOutputsTracking)();
-    }
-};
-exports.handleOutputsChanges = handleOutputsChanges;

package/dist/src/daemon/server/handle-outputs-tracking.d.ts

@@ -1,15 +0,0 @@
-import { HandlerResult } from './server';
-export declare function handleRecordOutputsHashBatch(payload: {
-    type: string;
-    data: {
-        outputs: string[];
-        hash: string;
-    }[];
-}): Promise<HandlerResult>;
-export declare function handleOutputsHashesMatchBatch(payload: {
-    type: string;
-    data: {
-        outputs: string[];
-        hash: string;
-    }[];
-}): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-outputs-tracking.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRecordOutputsHashBatch = handleRecordOutputsHashBatch;
-exports.handleOutputsHashesMatchBatch = handleOutputsHashesMatchBatch;
-const outputs_tracking_1 = require("./outputs-tracking");
-async function handleRecordOutputsHashBatch(payload) {
-    try {
-        (0, outputs_tracking_1.recordOutputsHashBatch)(payload.data);
-        return {
-            description: 'recordOutputsHashBatch',
-            response: '{}',
-        };
-    }
-    catch (e) {
-        return {
-            description: 'recordOutputsHashBatch failed',
-            error: new Error(`Critical error when recording metadata about outputs: '${e.message}'.`),
-        };
-    }
-}
-async function handleOutputsHashesMatchBatch(payload) {
-    try {
-        const results = (0, outputs_tracking_1.outputsHashesMatchBatch)(payload.data);
-        return {
-            response: results,
-            description: 'outputsHashesMatchBatch',
-        };
-    }
-    catch (e) {
-        return {
-            description: 'outputsHashesMatchBatch failed',
-            error: new Error(`Critical error when verifying the contents of the outputs haven't changed: '${e.message}'.`),
-        };
-    }
-}

package/dist/src/daemon/server/handle-process-in-background.d.ts

@@ -1,6 +0,0 @@
-import { HandlerResult } from './server';
-export declare function handleProcessInBackground(payload: {
-    type: string;
-    requirePath: string;
-    data: any;
-}): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-process-in-background.js

@@ -1,32 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleProcessInBackground = handleProcessInBackground;
-const logger_1 = require("../logger");
-const installation_directory_1 = require("../../utils/installation-directory");
-async function handleProcessInBackground(payload) {
-    let fn;
-    try {
-        fn = require(require.resolve(payload.requirePath, {
-            paths: (0, installation_directory_1.getNxRequirePaths)(),
-        })).default;
-    }
-    catch (e) {
-        return {
-            description: `Unable to require ${payload.requirePath}`,
-            error: new Error(`Unable to require ${payload.requirePath}`),
-        };
-    }
-    try {
-        const response = await fn(payload.data, logger_1.serverLogger);
-        return {
-            response,
-            description: payload.type,
-        };
-    }
-    catch (e) {
-        return {
-            description: `Error when processing ${payload.type}.`,
-            error: e,
-        };
-    }
-}

package/dist/src/daemon/server/handle-request-project-graph.d.ts

@@ -1,3 +0,0 @@
-import { Socket } from 'net';
-import { HandlerResult } from './server';
-export declare function handleRequestProjectGraph(socket: Socket): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-request-project-graph.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRequestProjectGraph = handleRequestProjectGraph;
-const perf_hooks_1 = require("perf_hooks");
-const socket_utils_1 = require("../socket-utils");
-const logger_1 = require("../logger");
-const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
-async function handleRequestProjectGraph(socket) {
-    try {
-        perf_hooks_1.performance.mark('server-connection');
-        logger_1.serverLogger.requestLog('Client Request for Project Graph Received');
-        const result = await (0, project_graph_incremental_recomputation_1.getCachedSerializedProjectGraphPromise)(socket);
-        if (result.error) {
-            return {
-                description: `Error when preparing serialized project graph.`,
-                error: result.error,
-            };
-        }
-        const serializedResult = (0, socket_utils_1.serializeResult)(result.error, result.serializedProjectGraph, result.serializedSourceMaps);
-        if (!serializedResult) {
-            return {
-                description: `Error when serializing project graph result.`,
-                error: new Error('Critical error when serializing server result, check server logs'),
-            };
-        }
-        perf_hooks_1.performance.mark('serialized-project-graph-ready');
-        perf_hooks_1.performance.measure('total for creating and serializing project graph', 'server-connection', 'serialized-project-graph-ready');
-        return { response: serializedResult, description: 'project-graph' };
-    }
-    catch (e) {
-        return {
-            description: `Unexpected error when creating Project Graph.`,
-            error: e,
-        };
-    }
-}

package/dist/src/daemon/server/handle-request-shutdown.d.ts

@@ -1,5 +0,0 @@
-import { Server } from 'net';
-export declare function handleRequestShutdown(server: Server, numberOfConnections: number): Promise<{
-    description: string;
-    response: string;
-}>;

package/dist/src/daemon/server/handle-request-shutdown.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRequestShutdown = handleRequestShutdown;
-const shutdown_utils_1 = require("./shutdown-utils");
-const server_1 = require("./server");
-async function handleRequestShutdown(server, numberOfConnections) {
-    // 1 connection is the client asking to shut down
-    if (numberOfConnections > 1) {
-        return {
-            description: `Unable to shutdown the daemon. ${numberOfConnections} connections are open.`,
-            response: '{}',
-        };
-    }
-    else {
-        setTimeout(async () => {
-            await (0, shutdown_utils_1.handleServerProcessTermination)({
-                server,
-                reason: 'Request to shutdown',
-                sockets: server_1.openSockets,
-            });
-        }, 0);
-        return {
-            description: 'Shutdown initiated',
-            response: '{}',
-        };
-    }
-}

package/dist/src/daemon/server/handle-task-history.d.ts

@@ -1,13 +0,0 @@
-import type { TaskRun, TaskTarget } from '../../native';
-export declare function handleRecordTaskRuns(taskRuns: TaskRun[]): Promise<{
-    response: string;
-    description: string;
-}>;
-export declare function handleGetFlakyTasks(hashes: string[]): Promise<{
-    response: string[];
-    description: string;
-}>;
-export declare function handleGetEstimatedTaskTimings(targets: TaskTarget[]): Promise<{
-    response: Record<string, number>;
-    description: string;
-}>;

package/dist/src/daemon/server/handle-task-history.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRecordTaskRuns = handleRecordTaskRuns;
-exports.handleGetFlakyTasks = handleGetFlakyTasks;
-exports.handleGetEstimatedTaskTimings = handleGetEstimatedTaskTimings;
-const task_history_1 = require("../../utils/task-history");
-async function handleRecordTaskRuns(taskRuns) {
-    const taskHistory = (0, task_history_1.getTaskHistory)();
-    await taskHistory.recordTaskRuns(taskRuns);
-    return {
-        response: 'true',
-        description: 'handleRecordTaskRuns',
-    };
-}
-async function handleGetFlakyTasks(hashes) {
-    const taskHistory = (0, task_history_1.getTaskHistory)();
-    const history = await taskHistory.getFlakyTasks(hashes);
-    return {
-        response: history,
-        description: 'handleGetFlakyTasks',
-    };
-}
-async function handleGetEstimatedTaskTimings(targets) {
-    const taskHistory = (0, task_history_1.getTaskHistory)();
-    const history = await taskHistory.getEstimatedTaskTimings(targets);
-    return {
-        response: history,
-        description: 'handleGetEstimatedTaskTimings',
-    };
-}

package/dist/src/daemon/server/handle-tasks-execution-hooks.d.ts

@@ -1,19 +0,0 @@
-import type { PostTasksExecutionContext, PreTasksExecutionContext } from '../../project-graph/plugins/public-api';
-export declare function handleRunPreTasksExecution(context: PreTasksExecutionContext): Promise<{
-    response: NodeJS.ProcessEnv[];
-    description: string;
-    error?: undefined;
-} | {
-    response?: undefined;
-    error: any;
-    description: string;
-}>;
-export declare function handleRunPostTasksExecution(context: PostTasksExecutionContext): Promise<{
-    error?: undefined;
-    response: string;
-    description: string;
-} | {
-    response?: undefined;
-    error: any;
-    description: string;
-}>;

package/dist/src/daemon/server/handle-tasks-execution-hooks.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleRunPreTasksExecution = handleRunPreTasksExecution;
-exports.handleRunPostTasksExecution = handleRunPostTasksExecution;
-const tasks_execution_hooks_1 = require("../../project-graph/plugins/tasks-execution-hooks");
-async function handleRunPreTasksExecution(context) {
-    try {
-        const envs = await (0, tasks_execution_hooks_1.runPreTasksExecution)(context);
-        return {
-            response: envs,
-            description: 'handleRunPreTasksExecution',
-        };
-    }
-    catch (e) {
-        return {
-            error: e,
-            description: `Error when running preTasksExecution.`,
-        };
-    }
-}
-async function handleRunPostTasksExecution(context) {
-    try {
-        await (0, tasks_execution_hooks_1.runPostTasksExecution)(context);
-        return {
-            response: 'true',
-            description: 'handleRunPostTasksExecution',
-        };
-    }
-    catch (e) {
-        return {
-            error: e,
-            description: `Error when running postTasksExecution.`,
-        };
-    }
-}

package/dist/src/daemon/server/handle-update-workspace-context.d.ts

@@ -1,2 +0,0 @@
-import type { HandlerResult } from './server';
-export declare function handleUpdateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<HandlerResult>;

package/dist/src/daemon/server/handle-update-workspace-context.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleUpdateWorkspaceContext = handleUpdateWorkspaceContext;
-const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
-async function handleUpdateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
-    (0, project_graph_incremental_recomputation_1.scheduleProjectGraphRecomputation)(createdFiles, updatedFiles, deletedFiles);
-    return {
-        response: '{}',
-        description: 'handleUpdateContextFiles',
-    };
-}

package/dist/src/daemon/server/latest-nx.d.ts

@@ -1,10 +0,0 @@
-/**
- * Returns the path to a temp directory containing `nx@latest`.
- * The installation is cached for the lifetime of the daemon process.
- * Guards against concurrent callers by reusing the in-flight promise.
- */
-export declare function getLatestNxTmpPath(): Promise<string>;
-/**
- * Clean up the latest Nx installation on daemon shutdown.
- */
-export declare function cleanupLatestNx(): void;

package/dist/src/daemon/server/latest-nx.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getLatestNxTmpPath = getLatestNxTmpPath;
-exports.cleanupLatestNx = cleanupLatestNx;
-// Import from the defining module, not the devkit-internals barrel: the barrel
-// eagerly pulls in the task-execution subsystem and instantiates a daemon
-// client, all of which would stay resident for the daemon server's lifetime.
-const package_json_1 = require("../../utils/package-json");
-const package_manager_1 = require("../../utils/package-manager");
-const provenance_1 = require("../../utils/provenance");
-const workspace_root_1 = require("../../utils/workspace-root");
-const logger_1 = require("../logger");
-// Module-level state - persists across invocations within daemon lifecycle
-let latestNxTmpPath = null;
-let cleanupFn = null;
-let installPromise = null;
-/**
- * Returns the path to a temp directory containing `nx@latest`.
- * The installation is cached for the lifetime of the daemon process.
- * Guards against concurrent callers by reusing the in-flight promise.
- */
-async function getLatestNxTmpPath() {
-    if (latestNxTmpPath !== null) {
-        logger_1.serverLogger.log('[LATEST-NX]: Reusing cached Nx installation from', latestNxTmpPath);
-        return latestNxTmpPath;
-    }
-    if (installPromise) {
-        return installPromise;
-    }
-    installPromise = (async () => {
-        try {
-            logger_1.serverLogger.log('[LATEST-NX]: Pulling latest Nx...');
-            await (0, provenance_1.ensurePackageHasProvenance)('nx', 'latest');
-            const result = await (0, package_json_1.installPackageToTmpAsync)('nx', 'latest', (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot));
-            latestNxTmpPath = result.tempDir;
-            cleanupFn = result.cleanup;
-            logger_1.serverLogger.log('[LATEST-NX]: Successfully pulled latest Nx to', latestNxTmpPath);
-            return latestNxTmpPath;
-        }
-        finally {
-            installPromise = null;
-        }
-    })();
-    return installPromise;
-}
-/**
- * Clean up the latest Nx installation on daemon shutdown.
- */
-function cleanupLatestNx() {
-    if (cleanupFn) {
-        logger_1.serverLogger.log('[LATEST-NX]: Cleaning up latest Nx installation from', latestNxTmpPath);
-        cleanupFn();
-    }
-    latestNxTmpPath = null;
-    cleanupFn = null;
-}

package/dist/src/daemon/server/nx-console-operations.d.ts

@@ -1,26 +0,0 @@
-/**
- * Gets the Nx Console status (whether we should prompt the user to install).
- * Uses latest Nx version if available, falls back to local implementation.
- *
- * @returns boolean indicating whether we should prompt the user
- */
-export declare function getNxConsoleStatus({ inner, }?: {
-    inner?: boolean;
-}): Promise<boolean>;
-/**
- * Handles user preference submission and installs Nx Console if requested.
- * Uses latest Nx version if available, falls back to local implementation.
- *
- * @param preference - whether the user wants to install Nx Console
- * @returns object indicating whether installation succeeded
- */
-export declare function handleNxConsolePreferenceAndInstall({ preference, inner, }: {
-    preference: boolean;
-    inner?: boolean;
-}): Promise<{
-    installed: boolean;
-}>;
-export declare function getNxConsoleStatusImpl(): Promise<boolean>;
-export declare function handleNxConsolePreferenceAndInstallImpl(preference: boolean): Promise<{
-    installed: boolean;
-}>;