fix iwsdk improve the cosmo cli path

Summary:
Fix Meta Spatial CLI Path Resolution for Multiple Versions and Add Cross-Platform Support

# Problem

  The previous implementation had several issues:
  1. Incorrect Windows version selection: Used files[0] which would randomly pick the first directory entry instead of the
  highest version number
  2. No environment variable support: No way to override the CLI path for custom installations
  3. Missing Linux support: Only handled macOS and Windows platforms

# Changes

 ## 1. Fixed Windows Version Selection

  - Implemented getHighestVersion() function that correctly identifies and selects the highest version number
  - Properly sorts version directories numerically (e.g., v20 > v9 > v2, not alphabetically)
  - Handles edge cases like multi-digit versions (v100) and missing version directories

- Before:
  const files = fs.readdirSync(directoryPath);
  metaSpatialCliPath = directoryPath + files[0] + '\Resources\CLI.exe'; // ❌ Wrong

 - After:
  const highestVersion = getHighestVersion(directoryPath);
  if (highestVersion) {
    metaSpatialCliPath = path.join(directoryPath, highestVersion, 'Resources', 'CLI.exe'); // ✅ Uses v20
  }

 ## 2. Added Environment Variable Support

  - Added META_SPATIAL_EDITOR_CLI_PATH environment variable check
  - Takes priority over platform-specific defaults
  - Allows users to specify custom CLI paths for non-standard installations

 ## 3. Added Linux Platform Support

  - Falls back to MetaSpatialEditorCLI command (assumes it's in PATH)
  - Covers all major platforms: macOS, Windows, and Linux

 # Resolution Priority

  1. META_SPATIAL_EDITOR_CLI_PATH environment variable (if set)
  2. Platform-specific defaults:
    - macOS: /Applications/Meta Spatial Editor.app/Contents/MacOS/CLI
    - Windows: C:\Program Files\Meta Spatial Editor\v{highest}\Resources\CLI.exe
    - Linux: MetaSpatialEditorCLI (from PATH)

Reviewed By: sforte, zjm-meta

Differential Revision:
D88068427

Privacy Context Container: L1334777

fbshipit-source-id: e8373635032e235ac00615adfd2d33ade3690431

Author: Peter Wang

packages/vite-plugin-metaspatial/package.json

@@ -12,7 +12,10 @@
   "scripts": {
     "build": "rollup -c",
     "dev": "rollup -c --watch",
-    "clean": "rm -rf dist"
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "keywords": [
     "vite",
@@ -39,7 +42,9 @@
   "devDependencies": {
     "@types/babel__traverse": "^7.20.6",
     "@types/chokidar": "^2.1.7",
-    "@types/fs-extra": "^11.0.4"
+    "@types/fs-extra": "^11.0.4",
+    "vitest": "^2.1.8",
+    "@vitest/coverage-v8": "^2.1.8"
   },
   "peerDependencies": {
     "vite": "^7.0.0"

packages/vite-plugin-metaspatial/src/generate-glxf/cli-path-resolver.ts

@@ -0,0 +1,73 @@
+/**
+ * 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 * as path from 'path';
+import fs from 'fs-extra';
+
+/**
+ * Get the highest version directory from Meta Spatial Editor installation
+ * @param directoryPath - Base directory path
+ * @returns The version folder with the highest version number (e.g., 'v20')
+ */
+export function getHighestVersion(directoryPath: string): string | null {
+  try {
+    const files = fs.readdirSync(directoryPath);
+
+    // Filter for version directories (e.g., v1, v2, v20)
+    const versionDirs = files.filter(file => {
+      const fullPath = path.join(directoryPath, file);
+      return fs.statSync(fullPath).isDirectory() && /^v\d+$/.test(file);
+    });
+
+    if (versionDirs.length === 0) {
+      return null;
+    }
+
+    // Sort by version number (extract number from 'vN' format)
+    versionDirs.sort((a, b) => {
+      const numA = parseInt(a.substring(1), 10);
+      const numB = parseInt(b.substring(1), 10);
+      return numB - numA; // Descending order (highest first)
+    });
+
+    return versionDirs[0];
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${directoryPath}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Resolve the Meta Spatial CLI path based on environment and platform
+ * @returns The path to the Meta Spatial CLI executable
+ */
+export function resolveMetaSpatialCliPath(): string {
+  // First, check if META_SPATIAL_EDITOR_CLI_PATH environment variable is set
+  if (process.env.META_SPATIAL_EDITOR_CLI_PATH) {
+    return process.env.META_SPATIAL_EDITOR_CLI_PATH;
+  }
+
+  // Fall back to platform-specific defaults
+  const os = process.platform;
+
+  if (os === 'darwin') {
+    return '/Applications/Meta Spatial Editor.app/Contents/MacOS/CLI';
+  } else if (os === 'win32') {
+    const directoryPath = 'C:\\Program Files\\Meta Spatial Editor\\';
+    const highestVersion = getHighestVersion(directoryPath);
+
+    if (highestVersion) {
+      return path.join(directoryPath, highestVersion, 'Resources', 'CLI.exe');
+    } else {
+      // Fallback to a default path if no version directories found
+      return path.join(directoryPath, 'Resources', 'CLI.exe');
+    }
+  } else {
+    // Linux - assume MetaSpatialEditorCLI is in PATH
+    return 'MetaSpatialEditorCLI';
+  }
+}

packages/vite-plugin-metaspatial/src/generate-glxf/index.ts

@@ -11,6 +11,7 @@ import fs from 'fs-extra';
 import type { Plugin, ViteDevServer } from 'vite';
 import { regenerateGLXF, createFileWatcher, cleanup } from './file-watcher.js';
 import type { GLXFGenerationOptions, ProcessedGLXFOptions } from './types.js';
+import { resolveMetaSpatialCliPath } from './cli-path-resolver.js';
 
 // Export types
 export type { GLXFGenerationOptions } from './types.js';
@@ -30,24 +31,12 @@ interface GLXFGenerationStat {
 function processOptions(
   options: GLXFGenerationOptions = {},
 ): ProcessedGLXFOptions {
-  const os = process.platform;
-  var metaSpatialCliPath;
-
-  if (os === 'darwin') {
-    metaSpatialCliPath =
-      '/Applications/Meta Spatial Editor.app/Contents/MacOS/CLI';
-  } else {
-    const directoryPath = 'C:\\Program Files\\Meta Spatial Editor\\';
-    const files = fs.readdirSync(directoryPath);
-    metaSpatialCliPath = directoryPath + files[0] + '\\Resources\\CLI.exe';
-  }
-
   return {
     metaSpatialDir: 'metaspatial',
     outputDir: 'generated/glxf',
     watchDebounceMs: 500,
     formats: ['glxf'] as const,
-    metaSpatialCliPath: metaSpatialCliPath,
+    metaSpatialCliPath: resolveMetaSpatialCliPath(),
     verbose: false,
     enableWatcher: true,
     ignorePattern: /components\//,

packages/vite-plugin-metaspatial/tests/cli-path-resolver.test.ts

@@ -0,0 +1,203 @@
+/**
+ * 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, vi } from 'vitest';
+import { getHighestVersion, resolveMetaSpatialCliPath } from '../src/generate-glxf/cli-path-resolver.js';
+import fs from 'fs-extra';
+import * as path from 'path';
+
+// Mock fs module
+vi.mock('fs-extra');
+
+describe('CLI Path Resolver', () => {
+  let originalPlatform: string;
+  let originalEnv: NodeJS.ProcessEnv;
+
+  beforeEach(() => {
+    // Save original values
+    originalPlatform = process.platform;
+    originalEnv = { ...process.env };
+
+    // Clear mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    // Restore original values
+    Object.defineProperty(process, 'platform', {
+      value: originalPlatform,
+    });
+    process.env = originalEnv;
+  });
+
+  describe('getHighestVersion', () => {
+    it('should return the highest version number', () => {
+      const mockFiles = ['v1', 'v2', 'v9', 'v11', 'v12', 'v20', 'other-file.txt'];
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation((filePath: any) => {
+        const fileName = path.basename(filePath.toString());
+        return {
+          isDirectory: () => /^v\d+$/.test(fileName),
+        } as any;
+      });
+
+      const result = getHighestVersion('C:\\Program Files\\Meta Spatial Editor\\');
+
+      expect(result).toBe('v20');
+    });
+
+    it('should handle single version directory', () => {
+      const mockFiles = ['v5'];
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation((filePath: any) => {
+        const fileName = path.basename(filePath.toString());
+        return {
+          isDirectory: () => /^v\d+$/.test(fileName),
+        } as any;
+      });
+
+      const result = getHighestVersion('C:\\Program Files\\Meta Spatial Editor\\');
+
+      expect(result).toBe('v5');
+    });
+
+    it('should return null when no version directories exist', () => {
+      const mockFiles = ['other-file.txt', 'config.json'];
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation(() => {
+        return {
+          isDirectory: () => false,
+        } as any;
+      });
+
+      const result = getHighestVersion('C:\\Program Files\\Meta Spatial Editor\\');
+
+      expect(result).toBeNull();
+    });
+
+    it('should correctly sort multi-digit version numbers', () => {
+      const mockFiles = ['v2', 'v100', 'v20', 'v3'];
+
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation((filePath: any) => {
+        const fileName = path.basename(filePath.toString());
+        return {
+          isDirectory: () => /^v\d+$/.test(fileName),
+        } as any;
+      });
+
+      const result = getHighestVersion('C:\\Program Files\\Meta Spatial Editor\\');
+
+      expect(result).toBe('v100');
+    });
+
+    it('should handle directory read errors gracefully', () => {
+      vi.mocked(fs.readdirSync).mockImplementation(() => {
+        throw new Error('Directory not found');
+      });
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      const result = getHighestVersion('C:\\Program Files\\Meta Spatial Editor\\');
+
+      expect(result).toBeNull();
+      expect(consoleWarnSpy).toHaveBeenCalled();
+
+      consoleWarnSpy.mockRestore();
+    });
+  });
+
+  describe('resolveMetaSpatialCliPath', () => {
+    it('should use META_SPATIAL_EDITOR_CLI_PATH environment variable if set', () => {
+      process.env.META_SPATIAL_EDITOR_CLI_PATH = '/custom/path/to/CLI';
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toBe('/custom/path/to/CLI');
+    });
+
+    it('should return macOS path when platform is darwin and no env var is set', () => {
+      delete process.env.META_SPATIAL_EDITOR_CLI_PATH;
+      Object.defineProperty(process, 'platform', {
+        value: 'darwin',
+      });
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toBe('/Applications/Meta Spatial Editor.app/Contents/MacOS/CLI');
+    });
+
+    it('should return Windows path with highest version when platform is win32', () => {
+      delete process.env.META_SPATIAL_EDITOR_CLI_PATH;
+      Object.defineProperty(process, 'platform', {
+        value: 'win32',
+      });
+
+      const mockFiles = ['v1', 'v2', 'v20'];
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation((filePath: any) => {
+        const fileName = path.basename(filePath.toString());
+        return {
+          isDirectory: () => /^v\d+$/.test(fileName),
+        } as any;
+      });
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toContain('v20');
+      expect(result).toContain('Resources');
+      expect(result).toContain('CLI.exe');
+    });
+
+    it('should return Windows fallback path when no version directories found', () => {
+      delete process.env.META_SPATIAL_EDITOR_CLI_PATH;
+      Object.defineProperty(process, 'platform', {
+        value: 'win32',
+      });
+
+      const mockFiles = ['other-file.txt'];
+      vi.mocked(fs.readdirSync).mockReturnValue(mockFiles as any);
+      vi.mocked(fs.statSync).mockImplementation(() => {
+        return {
+          isDirectory: () => false,
+        } as any;
+      });
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toContain('Resources');
+      expect(result).toContain('CLI.exe');
+      expect(result).not.toContain('v');
+    });
+
+    it('should return MetaSpatialEditorCLI for Linux platform', () => {
+      delete process.env.META_SPATIAL_EDITOR_CLI_PATH;
+      Object.defineProperty(process, 'platform', {
+        value: 'linux',
+      });
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toBe('MetaSpatialEditorCLI');
+    });
+
+    it('should prioritize environment variable over platform detection', () => {
+      process.env.META_SPATIAL_EDITOR_CLI_PATH = '/override/path';
+      Object.defineProperty(process, 'platform', {
+        value: 'darwin',
+      });
+
+      const result = resolveMetaSpatialCliPath();
+
+      expect(result).toBe('/override/path');
+      expect(result).not.toBe('/Applications/Meta Spatial Editor.app/Contents/MacOS/CLI');
+    });
+  });
+});

packages/vite-plugin-metaspatial/vitest.config.ts

@@ -0,0 +1,27 @@
+/**
+ * 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 { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        'tests/',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/rollup.config.js',
+      ],
+    },
+  },
+});