Add MSE detection and version validation

Summary:
Add platform detection and version validation utilities for Meta Spatial Editor (MSE). These functions detect if MSE is installed and validate version compatibility.

Functions added:
- `normalizeVersion()` - Normalizes version strings to major.minor.patch format
- `detectPlatform()` - Detects macOS, Windows, or Linux
- `detectMSEVersion()` - Finds installed MSE version via plist (macOS), registry (Windows), or CLI (Linux)
- `isVersionSufficient()` - Validates installed version meets minimum requirements

Also includes comprehensive unit tests for all detection functions.

This is part 2 of 4 for the MSE auto-install feature.

Reviewed By: wangpingsx

Differential Revision: D91470650

fbshipit-source-id: 4bad43d7b47570da076346de9a3ebe7e2f2e33a7

Author: ycliu613

packages/create/src/mse-installer.ts

@@ -0,0 +1,102 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import semver from 'semver';
+import {
+  MSE_MIN_VERSION,
+  MSE_INSTALL_PATHS,
+  MSE_LINUX_CLI_NAME,
+} from './mse-config.js';
+import type { Platform } from './types.js';
+
+/** Normalize version to major.minor.patch for comparison */
+export function normalizeVersion(v: string): string {
+  const parts = v.split('.');
+  while (parts.length < 3) parts.push('0');
+  return parts.slice(0, 3).join('.');
+}
+
+export function detectPlatform(): Platform {
+  const p = process.platform;
+  return p === 'darwin' || p === 'win32' ? p : 'linux';
+}
+
+/** Get highest version directory (e.g., v20) from Windows install path */
+function getHighestVersion(directoryPath: string): string | null {
+  try {
+    const entries = fs.readdirSync(directoryPath, { withFileTypes: true });
+    const versions = entries
+      .filter((e) => e.isDirectory() && /^v\d+$/.test(e.name))
+      .map((e) => parseInt(e.name.slice(1), 10));
+    return versions.length ? `v${Math.max(...versions)}` : null;
+  } catch {
+    return null;
+  }
+}
+
+function getMacOSAppVersion(appPath: string): string | null {
+  const plistPath = path.join(appPath, 'Contents', 'Info.plist');
+  try {
+    const output = execSync(
+      `plutil -extract CFBundleShortVersionString raw "${plistPath}"`,
+      { encoding: 'utf-8', timeout: 5000 },
+    );
+    return output.trim();
+  } catch {
+    return null;
+  }
+}
+
+function getWindowsAppVersion(basePath: string): string | null {
+  const highestVersion = getHighestVersion(basePath);
+  if (!highestVersion) return null;
+  const vNum = parseInt(highestVersion.substring(1), 10);
+  return `${vNum}.0.0`;
+}
+
+function parseVersionFromOutput(output: string): string | null {
+  const match = output.match(/v?(\d+\.\d+\.\d+)/);
+  return match ? match[1] : null;
+}
+
+export async function detectMSEVersion(platform: Platform): Promise<string | null> {
+  if (platform === 'linux') {
+    const cliPath = path.join(MSE_INSTALL_PATHS.linux, MSE_LINUX_CLI_NAME);
+
+    if (fs.existsSync(cliPath)) {
+      try {
+        const output = execSync(`"${cliPath}" --version`, { encoding: 'utf-8', timeout: 5000 });
+        return parseVersionFromOutput(output);
+      } catch {
+        return null;
+      }
+    }
+
+    try {
+      const output = execSync('MetaSpatialEditorCLI --version', { encoding: 'utf-8', timeout: 5000 });
+      return parseVersionFromOutput(output);
+    } catch {
+      return null;
+    }
+  }
+
+  const installPath = MSE_INSTALL_PATHS[platform];
+  if (!installPath || !fs.existsSync(installPath)) return null;
+
+  return platform === 'darwin' ? getMacOSAppVersion(installPath) : getWindowsAppVersion(installPath);
+}
+
+export function isVersionSufficient(installed: string, required: string = MSE_MIN_VERSION): boolean {
+  try {
+    return semver.gte(installed, required);
+  } catch {
+    return false;
+  }
+}

packages/create/tests/mse-installer.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  detectPlatform,
+  isVersionSufficient,
+  normalizeVersion,
+} from '../src/mse-installer.js';
+import {
+  MSE_MIN_VERSION,
+  MSE_APP_NAMES,
+  getAppcastUrl,
+} from '../src/mse-config.js';
+
+describe('MSE Installer', () => {
+  let originalPlatform: string;
+
+  beforeEach(() => {
+    originalPlatform = process.platform;
+  });
+
+  afterEach(() => {
+    Object.defineProperty(process, 'platform', { value: originalPlatform });
+  });
+
+  describe('normalizeVersion', () => {
+    it('should pad version to 3 parts', () => {
+      expect(normalizeVersion('11')).toBe('11.0.0');
+      expect(normalizeVersion('11.0')).toBe('11.0.0');
+      expect(normalizeVersion('11.0.0')).toBe('11.0.0');
+    });
+
+    it('should truncate version to 3 parts', () => {
+      expect(normalizeVersion('11.0.0.10.576')).toBe('11.0.0');
+      expect(normalizeVersion('9.1.2.3.4.5')).toBe('9.1.2');
+    });
+
+    it('should handle single digit versions', () => {
+      expect(normalizeVersion('9')).toBe('9.0.0');
+    });
+
+    it('should preserve full 3-part versions', () => {
+      expect(normalizeVersion('9.1.2')).toBe('9.1.2');
+      expect(normalizeVersion('12.5.3')).toBe('12.5.3');
+    });
+  });
+
+  describe('detectPlatform', () => {
+    it('should return darwin for macOS', () => {
+      Object.defineProperty(process, 'platform', { value: 'darwin' });
+      expect(detectPlatform()).toBe('darwin');
+    });
+
+    it('should return win32 for Windows', () => {
+      Object.defineProperty(process, 'platform', { value: 'win32' });
+      expect(detectPlatform()).toBe('win32');
+    });
+
+    it('should return linux for Linux', () => {
+      Object.defineProperty(process, 'platform', { value: 'linux' });
+      expect(detectPlatform()).toBe('linux');
+    });
+
+    it('should return linux for unknown platforms', () => {
+      Object.defineProperty(process, 'platform', { value: 'freebsd' });
+      expect(detectPlatform()).toBe('linux');
+    });
+  });
+
+  describe('isVersionSufficient', () => {
+    it('should return true for versions >= minimum', () => {
+      expect(isVersionSufficient('9.0.0')).toBe(true);
+      expect(isVersionSufficient('9.0.1')).toBe(true);
+      expect(isVersionSufficient('10.0.0')).toBe(true);
+      expect(isVersionSufficient('11.0.0')).toBe(true);
+    });
+
+    it('should return false for versions < minimum', () => {
+      expect(isVersionSufficient('8.0.0')).toBe(false);
+      expect(isVersionSufficient('8.9.9')).toBe(false);
+      expect(isVersionSufficient('1.0.0')).toBe(false);
+    });
+
+    it('should accept custom minimum version', () => {
+      expect(isVersionSufficient('10.0.0', '10.0.0')).toBe(true);
+      expect(isVersionSufficient('9.9.9', '10.0.0')).toBe(false);
+    });
+
+    it('should return false for invalid versions', () => {
+      expect(isVersionSufficient('invalid')).toBe(false);
+      expect(isVersionSufficient('')).toBe(false);
+    });
+  });
+
+  describe('MSE Config', () => {
+    it('should have correct app names for all platforms', () => {
+      expect(MSE_APP_NAMES.darwin).toBe('cosmo_studio_for_macos');
+      expect(MSE_APP_NAMES.win32).toBe('cosmo_studio_for_windows');
+      expect(MSE_APP_NAMES.linux).toBe('cosmo_studio_cli_for_linux');
+    });
+
+    it('should generate correct appcast URLs', () => {
+      expect(getAppcastUrl('darwin')).toContain('cosmo_studio_for_macos');
+      expect(getAppcastUrl('darwin')).toContain('appcast.xml');
+      expect(getAppcastUrl('win32')).toContain('cosmo_studio_for_windows');
+      expect(getAppcastUrl('linux')).toContain('cosmo_studio_cli_for_linux');
+    });
+
+    it('should have minimum version set', () => {
+      expect(MSE_MIN_VERSION).toBe('9.0.0');
+    });
+  });
+
+  describe('Version comparison edge cases', () => {
+    it('should correctly compare normalized versions', () => {
+      // These should be considered equal after normalization
+      const v1 = normalizeVersion('11.0');
+      const v2 = normalizeVersion('11.0.0.10.576');
+      expect(v1).toBe(v2);
+    });
+
+    it('should handle version upgrade detection', () => {
+      const installed = normalizeVersion('10.0');
+      const latest = normalizeVersion('11.0.0.10.576');
+      expect(installed).not.toBe(latest);
+      expect(isVersionSufficient(installed, latest)).toBe(false);
+    });
+  });
+});