Reapply "feat(core): make console daemon check backgroundable and pull… (#33578)

This reverts commit 626fb08.

Author: FrozenPandaz

packages/nx/bin/init-local.ts

@@ -3,7 +3,9 @@ import { performance } from 'perf_hooks';
 import { commandsObject } from '../src/command-line/nx-commands';
 import { WorkspaceTypeAndRoot } from '../src/utils/find-workspace-root';
 import { stripIndents } from '../src/utils/strip-indents';
-import { ensureNxConsoleInstalled } from '../src/utils/nx-console-prompt';
+import { daemonClient } from '../src/daemon/client/client';
+import { prompt } from 'enquirer';
+import { output } from '../src/utils/output';
 
 /**
  * Nx is being run inside a workspace.
@@ -33,7 +35,7 @@ export async function initLocal(workspace: WorkspaceTypeAndRoot) {
 
     // Ensure NxConsole is installed if the user has it configured.
     try {
-      await ensureNxConsoleInstalled();
+      await ensureNxConsoleInstalledViaDaemon();
     } catch {}
 
     const command = process.argv[2];
@@ -121,6 +123,51 @@ function shouldDelegateToAngularCLI() {
   return commands.indexOf(command) > -1;
 }
 
+async function ensureNxConsoleInstalledViaDaemon(): Promise<void> {
+  // Only proceed if daemon is available
+  if (!daemonClient.enabled()) {
+    return;
+  }
+
+  // Get status from daemon
+  const status = await daemonClient.getNxConsoleStatus();
+
+  // If we should prompt the user
+  if (status.shouldPrompt && process.stdout.isTTY) {
+    output.log({
+      title: "Install Nx's official editor extension to:",
+      bodyLines: [
+        '- Enable your AI assistant to do more by understanding your workspace',
+        '- Add IntelliSense for Nx configuration files',
+        '- Explore your workspace visually',
+      ],
+    });
+
+    try {
+      const { shouldInstallNxConsole } = await prompt<{
+        shouldInstallNxConsole: boolean;
+      }>({
+        type: 'confirm',
+        name: 'shouldInstallNxConsole',
+        message: 'Install Nx Console? (you can uninstall anytime)',
+        initial: true,
+      });
+
+      // Set preference and install if user said yes
+      const result = await daemonClient.setNxConsolePreferenceAndInstall(
+        shouldInstallNxConsole
+      );
+
+      if (result.installed) {
+        output.log({ title: 'Successfully installed Nx Console!' });
+      }
+    } catch (error) {
+      // User cancelled or error occurred, save preference as false
+      await daemonClient.setNxConsolePreferenceAndInstall(false);
+    }
+  }
+}
+
 function handleAngularCLIFallbacks(workspace: WorkspaceTypeAndRoot) {
   if (process.argv[2] === 'update' && process.env.FORCE_NG_UPDATE != 'true') {
     console.log(

packages/nx/src/daemon/client/client.ts

@@ -96,6 +96,14 @@ import {
   PRE_TASKS_EXECUTION,
 } from '../message-types/run-tasks-execution-hooks';
 import { REGISTER_PROJECT_GRAPH_LISTENER } from '../message-types/register-project-graph-listener';
+import {
+  GET_NX_CONSOLE_STATUS,
+  type HandleGetNxConsoleStatusMessage,
+  type HandleSetNxConsolePreferenceAndInstallMessage,
+  type NxConsoleStatusResponse,
+  SET_NX_CONSOLE_PREFERENCE_AND_INSTALL,
+  type SetNxConsolePreferenceAndInstallResponse,
+} from '../message-types/nx-console';
 import { deserialize } from 'node:v8';
 import { isJsonMessage } from '../../utils/consume-messages-from-socket';
 import { isV8SerializerEnabled } from '../is-v8-serializer-enabled';
@@ -564,6 +572,23 @@ export class DaemonClient {
     return this.sendToDaemonViaQueue(message);
   }
 
+  getNxConsoleStatus(): Promise<NxConsoleStatusResponse> {
+    const message: HandleGetNxConsoleStatusMessage = {
+      type: GET_NX_CONSOLE_STATUS,
+    };
+    return this.sendToDaemonViaQueue(message);
+  }
+
+  setNxConsolePreferenceAndInstall(
+    preference: boolean
+  ): Promise<SetNxConsolePreferenceAndInstallResponse> {
+    const message: HandleSetNxConsolePreferenceAndInstallMessage = {
+      type: SET_NX_CONSOLE_PREFERENCE_AND_INSTALL,
+      preference,
+    };
+    return this.sendToDaemonViaQueue(message);
+  }
+
   async isServerAvailable(): Promise<boolean> {
     return new Promise((resolve) => {
       try {

packages/nx/src/daemon/message-types/nx-console.ts

@@ -0,0 +1,42 @@
+export const GET_NX_CONSOLE_STATUS = 'GET_NX_CONSOLE_STATUS' as const;
+export const SET_NX_CONSOLE_PREFERENCE_AND_INSTALL =
+  'SET_NX_CONSOLE_PREFERENCE_AND_INSTALL' as const;
+
+export type HandleGetNxConsoleStatusMessage = {
+  type: typeof GET_NX_CONSOLE_STATUS;
+};
+
+export type NxConsoleStatusResponse = {
+  shouldPrompt: boolean;
+};
+
+export type HandleSetNxConsolePreferenceAndInstallMessage = {
+  type: typeof SET_NX_CONSOLE_PREFERENCE_AND_INSTALL;
+  preference: boolean;
+};
+
+export type SetNxConsolePreferenceAndInstallResponse = {
+  installed: boolean;
+};
+
+export function isHandleGetNxConsoleStatusMessage(
+  message: unknown
+): message is HandleGetNxConsoleStatusMessage {
+  return (
+    typeof message === 'object' &&
+    message !== null &&
+    'type' in message &&
+    message['type'] === GET_NX_CONSOLE_STATUS
+  );
+}
+
+export function isHandleSetNxConsolePreferenceAndInstallMessage(
+  message: unknown
+): message is HandleSetNxConsolePreferenceAndInstallMessage {
+  return (
+    typeof message === 'object' &&
+    message !== null &&
+    'type' in message &&
+    message['type'] === SET_NX_CONSOLE_PREFERENCE_AND_INSTALL
+  );
+}

packages/nx/src/daemon/server/handle-nx-console.ts

@@ -0,0 +1,69 @@
+import type {
+  NxConsoleStatusResponse,
+  SetNxConsolePreferenceAndInstallResponse,
+} from '../message-types/nx-console';
+import type { HandlerResult } from './server';
+import {
+  getNxConsoleStatus,
+  handleNxConsolePreferenceAndInstall,
+} from './nx-console-operations';
+
+// Module-level state for caching
+let cachedShouldPrompt: boolean | null = null;
+let isComputing = false;
+
+export async function handleGetNxConsoleStatus(): Promise<HandlerResult> {
+  // Return cached result if available
+  if (cachedShouldPrompt !== null) {
+    const response: NxConsoleStatusResponse = {
+      shouldPrompt: cachedShouldPrompt,
+    };
+    return {
+      response,
+      description: 'handleGetNxConsoleStatus',
+    };
+  }
+
+  // Kick off background computation if not already running
+  if (!isComputing) {
+    isComputing = true;
+    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: NxConsoleStatusResponse = {
+    shouldPrompt: false,
+  };
+
+  return {
+    response,
+    description: 'handleGetNxConsoleStatus',
+  };
+}
+
+export async function handleSetNxConsolePreferenceAndInstall(
+  preference: boolean
+): Promise<HandlerResult> {
+  // Immediately update cache - we know the answer now!
+  // User answered the prompt, so we won't prompt again
+  cachedShouldPrompt = false;
+
+  const result = await handleNxConsolePreferenceAndInstall({ preference });
+
+  const response: SetNxConsolePreferenceAndInstallResponse = {
+    installed: result.installed,
+  };
+
+  return {
+    response,
+    description: 'handleSetNxConsolePreferenceAndInstall',
+  };
+}