plusui-native 0.2.100 → 0.2.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plusui-native",
-  "version": "0.2.100",
+  "version": "0.2.103",
   "description": "PlusUI CLI - Build C++ desktop apps modern UI ",
   "main": "src/index.js",
   "type": "module",
@@ -27,11 +27,11 @@
     "semver": "^7.6.0",
     "which": "^4.0.0",
     "execa": "^8.0.1",
-    "plusui-native-builder": "^0.1.98",
-    "plusui-native-connect": "^0.1.98"
+    "plusui-native-builder": "^0.1.101",
+    "plusui-native-connect": "^0.1.101"
   },
   "peerDependencies": {
-    "plusui-native-connect": "^0.1.98"
+    "plusui-native-connect": "^0.1.101"
   },
   "publishConfig": {
     "access": "public"

package/src/doctor/detectors/just.js

@@ -1,4 +1,6 @@
 import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
 import semver from 'semver';
 
 const REQUIRED_JUST_VERSION = '1.0.0';
@@ -16,30 +18,71 @@ async function tryCommand(command) {
   }
 }
 
-export async function detectJust() {
-  const result = await tryCommand('just --version');
+// Known install locations for just.exe on Windows.
+function getJustCandidatePaths() {
+  if (process.platform !== 'win32') return [];
+  const home = process.env.USERPROFILE || process.env.HOME || '';
+  const localApp = process.env.LOCALAPPDATA || join(home, 'AppData', 'Local');
+  return [
+    join(localApp, 'Microsoft', 'WinGet', 'Links', 'just.exe'),
+    join(localApp, 'Microsoft', 'WinGet', 'Packages', 'Casey.Just_Microsoft.Winget.Source_8wekyb3d8bbwe', 'just.exe'),
+    'C:\\Program Files\\just\\just.exe',
+    join(home, '.plusui', 'bin', 'just.exe'),
+    join(home, '.cargo', 'bin', 'just.exe'),
+    join(home, 'scoop', 'shims', 'just.exe'),
+    join(home, 'scoop', 'apps', 'just', 'current', 'just.exe'),
+  ];
+}
 
-  if (!result.success) {
+export async function detectJust() {
+  // 1. Try PATH first
+  const pathResult = await tryCommand('just --version');
+  if (pathResult.success) {
+    const versionMatch = pathResult.output.match(/just (\d+\.\d+\.\d+)/);
+    const version = versionMatch ? versionMatch[1] : null;
     return {
-      found: false,
-      version: null,
-      valid: false,
+      found: true,
+      inPath: true,
+      version: version || 'unknown',
+      valid: version ? semver.gte(version, REQUIRED_JUST_VERSION) : true,
       requiredVersion: REQUIRED_JUST_VERSION
     };
   }
 
-  // Parse version (output format: "just 1.34.0")
-  const versionMatch = result.output.match(/just (\d+\.\d+\.\d+)/);
-  const version = versionMatch ? versionMatch[1] : null;
+  // 2. On Windows, probe known install locations
+  if (process.platform === 'win32') {
+    for (const candidate of getJustCandidatePaths()) {
+      if (existsSync(candidate)) {
+        const result = await tryCommand(`"${candidate}" --version`);
+        if (result.success) {
+          const versionMatch = result.output.match(/just (\d+\.\d+\.\d+)/);
+          const version = versionMatch ? versionMatch[1] : null;
 
-  // If we can't parse the version but the command succeeded, assume it's valid enough
-  // but ideally we check version. Just is usually pretty standard.
-  const valid = version ? semver.gte(version, REQUIRED_JUST_VERSION) : true;
+          // Inject the directory into the current process PATH so subsequent
+          // calls (e.g. the Justfile runner) can find just without a new terminal.
+          const dir = dirname(candidate);
+          if (!process.env.PATH.includes(dir)) {
+            process.env.PATH = dir + ';' + process.env.PATH;
+          }
+
+          return {
+            found: true,
+            inPath: false,  // found on disk but not originally in PATH
+            foundPath: candidate,
+            version: version || 'unknown',
+            valid: version ? semver.gte(version, REQUIRED_JUST_VERSION) : true,
+            requiredVersion: REQUIRED_JUST_VERSION
+          };
+        }
+      }
+    }
+  }
 
   return {
-    found: true,
-    version: version || 'unknown',
-    valid,
+    found: false,
+    inPath: false,
+    version: null,
+    valid: false,
     requiredVersion: REQUIRED_JUST_VERSION
   };
 }

package/src/doctor/index.js

@@ -102,11 +102,16 @@ export class EnvironmentDoctor {
     console.log(chalk.bold('\nInstallation Results\n'));
     console.log('====================\n');
 
+    let anyPathRefreshNeeded = false;
+
     for (const result of fixResults) {
       if (result.success) {
-        console.log(chalk.green(`✓ ${result.name} installed successfully`));
-        if (result.pathRefreshNeeded) {
-          console.log(chalk.gray('  Note: open a new terminal for the updated PATH to take effect'));
+        const alreadyHad = result.message && /already installed/i.test(result.message);
+        if (alreadyHad) {
+          console.log(chalk.green(`✓ ${result.name} already installed and up to date`));
+        } else {
+          console.log(chalk.green(`✓ ${result.name} installed successfully`));
+          if (result.pathRefreshNeeded) anyPathRefreshNeeded = true;
         }
       } else {
         console.log(chalk.red(`✗ ${result.name} installation failed`));
@@ -128,8 +133,18 @@ export class EnvironmentDoctor {
       }
     }
 
+    if (anyPathRefreshNeeded) {
+      console.log(chalk.yellow('\n  ACTION REQUIRED: Refresh your PATH to use the installed tools.'));
+      if (this.platform === 'win32') {
+        console.log(chalk.white('  Run this in your current terminal to reload PATH without reopening it:'));
+        console.log(chalk.cyan('\n  $env:PATH = [System.Environment]::GetEnvironmentVariable("PATH","Machine") + ";" + [System.Environment]::GetEnvironmentVariable("PATH","User")\n'));
+      } else {
+        console.log(chalk.white('  Run: source ~/.bashrc  (or open a new terminal)\n'));
+      }
+    }
+
     // Re-run diagnosis to verify
-    console.log(chalk.bold('\n\nVerifying installation...\n'));
+    console.log(chalk.bold('\nVerifying installation...\n'));
     const newResults = await this.diagnose();
 
     return newResults;

package/src/doctor/installers/linux.js

@@ -67,6 +67,35 @@ const TOOL_NAMES = {
 
 export async function installTool(toolName) {
   const name = TOOL_NAMES[toolName] || toolName;
+
+  // just: use the official install script with prebuilt binaries
+  if (toolName === 'just') {
+    console.log(`Installing ${name} from prebuilt binaries...`);
+    const destDir = `${process.env.HOME || '~'}/.plusui/bin`;
+    await tryCommand(`mkdir -p "${destDir}"`);
+    const result = await tryCommand(
+      `curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to "${destDir}"`,
+      120000
+    );
+    if (result.success) {
+      // Add to PATH in shell profiles
+      const addToPath = `grep -qF '.plusui/bin' "$HOME/.bashrc" 2>/dev/null || echo 'export PATH="$HOME/.plusui/bin:$PATH"' >> "$HOME/.bashrc"`;
+      await tryCommand(addToPath, 5000);
+      // Inject into current process PATH immediately
+      if (!process.env.PATH.includes(destDir)) {
+        process.env.PATH = destDir + ':' + process.env.PATH;
+      }
+      return {
+        success: true,
+        message: `${name} installed successfully`,
+        output: result.output,
+        pathRefreshNeeded: true
+      };
+    }
+    // Fall through to package manager if script failed
+    console.log(`  Direct install failed, trying package manager...`);
+  }
+
   const pm = await detectPackageManager();
 
   if (!pm) {
@@ -90,8 +119,6 @@ export async function installTool(toolName) {
   }
 
   console.log(`Installing ${name} via ${pm}...`);
-  console.log(`Running: ${command}`);
-
   const result = await tryCommand(command);
 
   if (result.success) {

package/src/doctor/installers/macos.js

@@ -30,6 +30,9 @@ const INSTALL_COMMANDS = {
     name: 'Node.js'
   },
   just: {
+    // Use the official install script with prebuilt binaries as primary method
+    installScript: `curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to "$HOME/.plusui/bin"`,
+    addToPath: `grep -qF '$HOME/.plusui/bin' "$HOME/.zshrc" 2>/dev/null || echo 'export PATH="$HOME/.plusui/bin:$PATH"' >> "$HOME/.zshrc"; grep -qF '$HOME/.plusui/bin' "$HOME/.bash_profile" 2>/dev/null || echo 'export PATH="$HOME/.plusui/bin:$PATH"' >> "$HOME/.bash_profile"`,
     command: 'brew install just',
     manual: 'https://github.com/casey/just/releases',
     name: 'Just Command Runner'
@@ -72,6 +75,33 @@ export async function installTool(toolName) {
     };
   }
 
+  // just: use the official install script with prebuilt binaries
+  if (toolName === 'just' && tool.installScript) {
+    console.log(`Installing ${tool.name} from prebuilt binaries...`);
+    const destDir = `${process.env.HOME || '~'}/.plusui/bin`;
+    const mkdirResult = await tryCommand(`mkdir -p "${destDir}"`);
+    const result = await tryCommand(
+      `curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to "${destDir}"`,
+      120000
+    );
+    if (result.success) {
+      // Add to PATH in shell profiles
+      await tryCommand(tool.addToPath, 5000);
+      // Inject into current process PATH immediately
+      if (!process.env.PATH.includes(destDir)) {
+        process.env.PATH = destDir + ':' + process.env.PATH;
+      }
+      return {
+        success: true,
+        message: `${tool.name} installed successfully`,
+        output: result.output,
+        pathRefreshNeeded: true
+      };
+    }
+    // Fall through to Homebrew if script failed
+    console.log(`  Direct install failed, trying Homebrew...`);
+  }
+
   // Check if Homebrew is available
   const hasHomebrew = await checkHomebrew();
 
@@ -91,7 +121,7 @@ export async function installTool(toolName) {
     };
   }
 
-  // Attempt auto-installation
+  // Attempt auto-installation via Homebrew
   console.log(`Installing ${tool.name} via Homebrew...`);
   const result = await tryCommand(tool.command);
 

package/src/doctor/installers/windows.js

@@ -1,4 +1,7 @@
 import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
 
 async function tryCommand(command, timeout = 30000) {
   try {
@@ -20,40 +23,110 @@ async function checkWinget() {
   return result.success;
 }
 
+// Run winget via cmd shell with output redirected to a temp file so it works
+// in non-interactive (piped) Node child processes where winget goes silent.
+async function tryWinget(args, timeout = 300000) {
+  const tmp = join(process.env.TEMP || 'C:\\Temp', `plusui_winget_${Date.now()}.txt`);
+  let exitOk = false;
+  try {
+    execSync(`cmd /c "winget ${args} > "${tmp}" 2>&1"`, { stdio: 'ignore', timeout, shell: false });
+    exitOk = true;
+  } catch (_) {}
+  let output = '';
+  try { output = execSync(`type "${tmp}"`, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim(); } catch (_) {}
+  try { execSync(`del /f /q "${tmp}"`, { stdio: 'ignore' }); } catch (_) {}
+  return { success: exitOk, output };
+}
+
+// Install just using the official prebuilt binaries from GitHub releases.
+// Uses PowerShell to download and extract — no bash required on Windows.
+async function installJustFromGitHub(destDir) {
+  const justExe = join(destDir, 'just.exe');
+
+  // Ensure destination directory exists
+  try { execSync(`cmd /c "mkdir "${destDir}" 2>nul"`, { stdio: 'ignore' }); } catch (_) {}
+
+  const psLines = [
+    `$ErrorActionPreference = 'Stop'`,
+    `$dest = '${destDir.replace(/\\/g, '\\\\')}'`,
+    `$exe  = '${justExe.replace(/\\/g, '\\\\')}'`,
+    // Fetch latest release metadata
+    `$rel  = Invoke-RestMethod -Uri 'https://api.github.com/repos/casey/just/releases/latest' -UseBasicParsing`,
+    // Pick the Windows x86_64 MSVC zip
+    `$asset = $rel.assets | Where-Object { $_.name -match 'x86_64-pc-windows-msvc\\.zip$' } | Select-Object -First 1`,
+    `if (-not $asset) { throw 'No Windows asset found in latest just release' }`,
+    `$zip = Join-Path $env:TEMP 'just_install.zip'`,
+    `Invoke-WebRequest -Uri $asset.browser_download_url -OutFile $zip -UseBasicParsing`,
+    `Expand-Archive -Path $zip -DestinationPath $dest -Force`,
+    `Remove-Item $zip -Force`,
+    `Write-Host "just installed to $exe"`,
+  ];
+
+  const result = await tryCommand(
+    `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "${psLines.join('; ')}"`,
+    120000
+  );
+
+  if (!result.success || !existsSync(justExe)) {
+    return { success: false, output: result.stdout + result.stderr };
+  }
+
+  // Add destDir to user PATH permanently (registry)
+  const addToPath = [
+    `$p = [Environment]::GetEnvironmentVariable('PATH','User')`,
+    `$d = '${destDir.replace(/\\/g, '\\\\')}' `,
+    `if ($p -notlike "*$d*") { [Environment]::SetEnvironmentVariable('PATH', ($p.TrimEnd(';') + ';' + $d), 'User') }`,
+  ];
+  await tryCommand(
+    `powershell -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "${addToPath.join('; ')}"`,
+    10000
+  );
+
+  // Also inject into the current process PATH so tools work immediately
+  if (!process.env.PATH.includes(destDir)) {
+    process.env.PATH = destDir + ';' + process.env.PATH;
+  }
+
+  return { success: true, justExe };
+}
+
 const INSTALL_COMMANDS = {
   cmake: {
-    // NOTE: Kitware.CMake does NOT support --scope user; omit it so winget
-    // uses the package's default (machine) scope.  winget will request UAC
-    // elevation automatically when needed.
-    command: 'winget install -e --id Kitware.CMake --accept-package-agreements --accept-source-agreements --disable-interactivity',
+    wingetId: 'Kitware.CMake',
+    wingetArgs: 'install -e --id Kitware.CMake --accept-package-agreements --accept-source-agreements --disable-interactivity',
     manual: 'https://cmake.org/download/',
     name: 'CMake',
     timeout: 300000,
     requiresElevation: true
   },
   nodejs: {
-    command: 'winget install -e --id OpenJS.NodeJS --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
+    wingetId: 'OpenJS.NodeJS',
+    wingetArgs: 'install -e --id OpenJS.NodeJS --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
     manual: 'https://nodejs.org/',
     name: 'Node.js',
     timeout: 300000
   },
   just: {
-    command: 'winget install -e --id Casey.Just --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
+    wingetId: 'Casey.Just',
+    wingetArgs: 'install -e --id Casey.Just --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
     manual: 'https://github.com/casey/just/releases',
     name: 'Just Command Runner',
     timeout: 300000
   },
   webview2: {
-    command: 'winget install -e --id Microsoft.EdgeWebView2Runtime --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
+    wingetId: 'Microsoft.EdgeWebView2Runtime',
+    wingetArgs: 'install -e --id Microsoft.EdgeWebView2Runtime --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity',
     manual: 'https://developer.microsoft.com/en-us/microsoft-edge/webview2/#download-section',
     name: 'WebView2 Runtime',
     timeout: 300000
   },
   visualstudio: {
-    command: 'winget install -e --id Microsoft.VisualStudio.2022.BuildTools --accept-package-agreements --accept-source-agreements --disable-interactivity --override "--wait --quiet --norestart --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.Windows11SDK.22621"',
+    wingetId: 'Microsoft.VisualStudio.2022.BuildTools',
+    wingetArgs: 'install -e --id Microsoft.VisualStudio.2022.BuildTools --accept-package-agreements --accept-source-agreements --disable-interactivity --override "--wait --quiet --norestart --add Microsoft.VisualStudio.Workload.VCTools --add Microsoft.VisualStudio.Component.VC.CMake.Project --add Microsoft.VisualStudio.Component.Windows11SDK.22621"',
     manual: 'https://visualstudio.microsoft.com/downloads/',
     name: 'Visual Studio 2022',
     timeout: 3600000,
+    requiresElevation: true,
     instructions: [
       '1. Download Visual Studio 2022 Build Tools or Community (free)',
       '2. Run the installer',
@@ -70,61 +143,59 @@ export async function installTool(toolName) {
   const tool = INSTALL_COMMANDS[toolName];
 
   if (!tool) {
-    return {
-      success: false,
-      error: `Unknown tool: ${toolName}`
-    };
+    return { success: false, error: `Unknown tool: ${toolName}` };
   }
 
-  // Check if winget is available
-  const hasWinget = await checkWinget();
+  // just gets its own install path using the official prebuilt binaries
+  if (toolName === 'just') {
+    return installJust(tool);
+  }
 
-  if (!hasWinget && tool.command) {
+  // All other tools go through winget
+  const hasWinget = await checkWinget();
+  if (!hasWinget) {
     return {
       success: false,
-      autoInstallAvailable: false,
-      manual: tool.manual,
       message: 'winget is not available. Please install manually.',
       downloadUrl: tool.manual
     };
   }
 
-  // Attempt auto-installation
   console.log(`Installing ${tool.name} via winget...`);
-  const result = await tryCommand(tool.command, tool.timeout || 300000);
+  const result = await tryWinget(tool.wingetArgs, tool.timeout || 300000);
 
   if (result.success) {
-    return {
-      success: true,
-      message: `${tool.name} installed successfully`,
-      output: result.output,
-      // Remind callers that the current process PATH won't include the new
-      // install – they should re-spawn or check known filesystem paths.
-      pathRefreshNeeded: true
-    };
+    return { success: true, message: `${tool.name} installed successfully`, output: result.output, pathRefreshNeeded: true };
   }
 
-  // Build a human-readable reason from winget's own output
-  const reason = result.stderr || result.stdout ||
-    (result.error && result.error.message) ||
-    'Unknown error';
+  const alreadyInstalled =
+    /No newer package versions are available/i.test(result.output) ||
+    /No available upgrade found/i.test(result.output) ||
+    /already installed/i.test(result.output);
+
+  if (alreadyInstalled) {
+    const upgradeResult = await tryWinget(
+      `upgrade -e --id ${tool.wingetId} --accept-package-agreements --accept-source-agreements --disable-interactivity`,
+      tool.timeout || 300000
+    );
+    if (upgradeResult.success) {
+      return { success: true, message: `${tool.name} installed successfully`, output: upgradeResult.output, pathRefreshNeeded: true };
+    }
+    return { success: true, message: `${tool.name} is already installed and up to date`, output: result.output, pathRefreshNeeded: true };
+  }
 
   const failResult = {
     success: false,
-    autoInstallAvailable: true,
-    error: result.error,
     message: `Failed to install ${tool.name} automatically`,
-    reason,
-    manual: tool.manual,
+    reason: result.output || 'Unknown error',
     downloadUrl: tool.manual
   };
 
   if (tool.requiresElevation) {
     failResult.instructions = [
       'This tool requires administrator rights to install system-wide.',
-      'Option 1: Re-run from an elevated (Run as Administrator) terminal:',
-      '          plusui doctor --fix',
-      `Option 2: Install manually via winget (elevated): ${tool.command}`,
+      'Option 1: Re-run from an elevated (Run as Administrator) terminal: plusui doctor --fix',
+      `Option 2: winget ${tool.wingetArgs}`,
       `Option 3: Download from: ${tool.manual}`
     ];
   }
@@ -132,15 +203,65 @@ export async function installTool(toolName) {
   return failResult;
 }
 
+async function installJust(tool) {
+  const destDir = join(homedir(), '.plusui', 'bin');
+  console.log(`Installing ${tool.name} from prebuilt binaries...`);
+
+  // Use the official prebuilt binary from GitHub releases
+  const ghResult = await installJustFromGitHub(destDir);
+  if (ghResult.success) {
+    return {
+      success: true,
+      message: `${tool.name} installed successfully`,
+      output: `Installed to ${ghResult.justExe}`,
+      pathRefreshNeeded: true
+    };
+  }
+
+  // Fallback: try winget
+  console.log(`  Direct download failed, trying winget...`);
+  const wingetResult = await tryWinget(tool.wingetArgs, tool.timeout || 300000);
+  if (wingetResult.success) {
+    return { success: true, message: `${tool.name} installed successfully`, output: wingetResult.output, pathRefreshNeeded: true };
+  }
+
+  const wingetSaysInstalled =
+    /No newer package versions are available/i.test(wingetResult.output) ||
+    /No available upgrade found/i.test(wingetResult.output) ||
+    /already installed/i.test(wingetResult.output);
+
+  if (wingetSaysInstalled) {
+    const upgradeResult = await tryWinget(
+      `upgrade -e --id ${tool.wingetId} --scope user --accept-package-agreements --accept-source-agreements --disable-interactivity`,
+      tool.timeout || 300000
+    );
+    if (upgradeResult.success) {
+      return { success: true, message: `${tool.name} installed successfully`, output: upgradeResult.output, pathRefreshNeeded: true };
+    }
+    return { success: true, message: `${tool.name} is already installed and up to date`, output: wingetResult.output, pathRefreshNeeded: true };
+  }
+
+  return {
+    success: false,
+    message: `Failed to install ${tool.name} automatically`,
+    reason: ghResult.output || wingetResult.output || 'All install methods failed',
+    downloadUrl: tool.manual,
+    instructions: [
+      `winget install -e --id Casey.Just`,
+      `Or download from: ${tool.manual}`,
+      `Or via cargo: cargo install just`,
+    ]
+  };
+}
+
 export function getInstallInstructions(toolName) {
   const tool = INSTALL_COMMANDS[toolName];
   if (!tool) return null;
-
   return {
     name: tool.name,
     manual: tool.manual,
     instructions: tool.instructions || [
-      `Install via winget: ${tool.command}`,
+      `Install via winget: winget ${tool.wingetArgs}`,
       `Or download from: ${tool.manual}`
     ]
   };

package/src/doctor/reporter.js

@@ -72,7 +72,12 @@ export class DoctorReporter {
     // Just
     if (results.just.found) {
       if (results.just.valid) {
-        output += chalk.green(`✓ Just        v${results.just.version}\n`);
+        if (results.just.inPath === false && results.just.foundPath) {
+          output += chalk.yellow(`⚠ Just        v${results.just.version} (installed but not in PATH yet — open a new terminal)\n`);
+          output += chalk.gray(`              Found at: ${results.just.foundPath}\n`);
+        } else {
+          output += chalk.green(`✓ Just        v${results.just.version}\n`);
+        }
       } else {
         output += chalk.yellow(`⚠ Just        v${results.just.version} (requires >= ${results.just.requiredVersion})\n`);
       }
@@ -126,8 +131,19 @@ export class DoctorReporter {
     if (missingTools.length === 0) {
       output += chalk.green('Status: ✓ Ready to build PlusUI apps!\n');
     } else {
+      const missingNames = missingTools.map(t => {
+        switch (t.name) {
+          case 'nodejs': return 'Node.js';
+          case 'cmake': return 'CMake';
+          case 'compiler': return t.info.name || 'C++ Compiler';
+          case 'just': return 'Just';
+          case 'webview2': return 'WebView2';
+          default: return t.name;
+        }
+      });
       output += chalk.red(`Status: ✗ Needs Setup\n`);
-      output += `Missing: ${missingTools.length} required tool(s)\n`;
+      output += `Missing: ${missingNames.join(', ')}\n`;
+      output += chalk.yellow(`Run: plusui doctor --fix to install automatically\n`);
     }
 
     console.log(output);