@directivegames/genesys.sdk 3.2.2 → 3.2.4

package/src/templates/scripts/genesys/dev/storage-provider.ts

@@ -1,229 +1,229 @@
-import * as ENGINE from 'genesys.js';
-
-export type FileManifestItem = Omit<ENGINE.FileItem, 'absolutePath'>;
-
-export const ManifestPath = 'dist/file-manifest.json';
-
-export interface FileManifest {
-  generated: string;
-  projectFiles: Record<string, FileManifestItem[]>;
-  engineFiles: Record<string, FileManifestItem[]>;
-}
-
-export class DevStorageProvider implements ENGINE.IStorageProvider {
-  private manifestCache: FileManifest | null = null;
-  private manifestPromise: Promise<FileManifest> | null = null;
-
-  private async loadManifest(): Promise<FileManifest> {
-    if (this.manifestCache) {
-      return this.manifestCache;
-    }
-
-    if (this.manifestPromise) {
-      return this.manifestPromise;
-    }
-
-    this.manifestPromise = this.fetchManifest();
-    this.manifestCache = await this.manifestPromise;
-    this.manifestPromise = null;
-
-    return this.manifestCache;
-  }
-
-  private async fetchManifest(): Promise<FileManifest> {
-    try {
-      const response = await fetch(`/${ManifestPath}`);
-      if (!response.ok) {
-        throw new Error(`Failed to load manifest: ${response.status} ${response.statusText}`);
-      }
-      return await response.json();
-    } catch (error) {
-      console.warn('Failed to load file manifest, falling back to empty manifest:', error);
-      return {
-        generated: new Date().toISOString(),
-        projectFiles: {},
-        engineFiles: {}
-      };
-    }
-  }
-
-  async resolvePath(path: ENGINE.AssetPath, expiry?: number): Promise<ENGINE.AssetPath> {
-    if (path.isResolved()) {
-      return path;
-    }
-
-    let resolvedUrl: string;
-
-    if (path.initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
-      resolvedUrl = path.initialPath.replace(ENGINE.PROJECT_PATH_PREFIX, ENGINE.BUILT_PROJECT_FOLDER);
-    } else if (path.initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
-      resolvedUrl = path.initialPath.replace(ENGINE.ENGINE_PATH_PREFIX, '/node_modules/genesys.js');
-    } else if (path.initialPath.startsWith('/')) {
-      resolvedUrl = `/node_modules/genesys.js${path.initialPath}`;
-    } else if (path.initialPath.startsWith('http') || path.initialPath.startsWith('https')) {
-      resolvedUrl = path.initialPath;
-    } else {
-      // Paths without prefix are treated as engine paths
-      resolvedUrl = `/node_modules/genesys.js/${path.initialPath}`;
-    }
-
-    path.resolvePath(resolvedUrl, ENGINE.AssetPathEncodeState.Unknown);
-    return path;
-  }
-
-  async downloadFileAsBuffer(path: ENGINE.AssetPath): Promise<ArrayBuffer> {
-    const resolvedPath = await this.resolvePath(path);
-    const response = await fetch(resolvedPath.getResolvedPath());
-    this.checkResponse(path, response);
-    return response.arrayBuffer();
-  }
-
-  async downloadFileAsJson<T>(path: ENGINE.AssetPath): Promise<T> {
-    const resolvedPath = await this.resolvePath(path);
-    const response = await fetch(resolvedPath.getResolvedPath());
-    this.checkResponse(path, response);
-    return response.json();
-  }
-
-  async downloadFileAsText(path: ENGINE.AssetPath): Promise<string> {
-    const resolvedPath = await this.resolvePath(path);
-    const response = await fetch(resolvedPath.getResolvedPath());
-    this.checkResponse(path, response);
-    return response.text();
-  }
-
-  async uploadFile(
-    path: ENGINE.AssetPath,
-    content: Blob | File | string | ArrayBuffer,
-    options?: ENGINE.FileUploadOptions
-  ): Promise<{ path: string; name: string }> {
-    throw new Error('ViteDevStorageProvider does not support uploading files.');
-  }
-
-  async listFiles(
-    path: ENGINE.AssetPath,
-    recursive?: boolean,
-    includeHiddenFiles?: boolean
-  ): Promise<ENGINE.FileListResult> {
-    try {
-      const manifest = await this.loadManifest();
-      const initialPath = path.initialPath;
-      const targetPath = this.normalizePathForManifest(initialPath);
-
-      // Determine which file collection to use
-      // Paths without prefix are treated as engine assets
-      const isEngineAsset = initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX);
-      const isProjectAsset = initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX);
-      if (!isEngineAsset && !isProjectAsset) {
-        throw new Error(`Invalid path: ${path}`);
-      }
-      const fileCollection = isEngineAsset ? manifest.engineFiles : manifest.projectFiles;
-
-      const files: ENGINE.FileItem[] = [];
-      const directories: ENGINE.FileItem[] = [];
-
-      if (recursive) {
-        // For recursive listing, include all files that start with the target path
-        for (const [dirPath, items] of Object.entries(fileCollection)) {
-          if (dirPath === targetPath || dirPath.startsWith(targetPath + '/') || (targetPath === '' && !dirPath.includes('/'))) {
-            for (const item of items) {
-              const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
-
-              if (!includeHiddenFiles && item.name.startsWith('.')) {
-                continue;
-              }
-
-              if (item.isDirectory) {
-                directories.push(engineFileItem);
-              } else {
-                files.push(engineFileItem);
-              }
-            }
-          }
-        }
-      } else {
-        // For non-recursive listing, only include direct children
-        const directItems = fileCollection[targetPath] || [];
-
-        for (const item of directItems) {
-          const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
-
-          if (!includeHiddenFiles && item.name.startsWith('.')) {
-            continue;
-          }
-
-          // Only include direct children (not nested)
-          const itemDirPath = item.path.substring(0, item.path.lastIndexOf('/'));
-          const normalizedItemDirPath = itemDirPath === '.' || itemDirPath === '' ? '' : itemDirPath;
-
-          if (normalizedItemDirPath === targetPath) {
-            if (item.isDirectory) {
-              directories.push(engineFileItem);
-            } else {
-              files.push(engineFileItem);
-            }
-          }
-        }
-      }
-
-      return { files, directories };
-    } catch (error) {
-      console.warn(`Failed to list files for path ${path.initialPath}:`, error);
-      return { files: [], directories: [] };
-    }
-  }
-
-  async exists(path: ENGINE.AssetPath): Promise<boolean> {
-    try {
-      const resolvedPath = await this.resolvePath(path);
-      const response = await fetch(resolvedPath.getResolvedPath(), { method: 'HEAD' });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-
-  async buildCurrentProject(runTsc: boolean): Promise<boolean> {
-    // For development, we don't need to build the project
-    // Vite handles the compilation
-    return true;
-  }
-
-  private normalizePathForManifest(pathStr: string): string {
-    // Remove @project/ or @engine/ prefix
-    let normalized = pathStr.replace(ENGINE.PROJECT_PATH_PREFIX, '').replace(ENGINE.ENGINE_PATH_PREFIX, '');
-
-    // Remove leading slash if present
-    if (normalized.startsWith('/')) {
-      normalized = normalized.substring(1);
-    }
-
-    // Remove trailing slash if present
-    if (normalized.endsWith('/')) {
-      normalized = normalized.substring(0, normalized.length - 1);
-    }
-
-    return normalized;
-  }
-
-  private convertToEngineFileItem(manifestItem: FileManifestItem, isEngineAsset: boolean): ENGINE.FileItem {
-    const prefix = isEngineAsset ? ENGINE.ENGINE_PATH_PREFIX : ENGINE.PROJECT_PATH_PREFIX;
-    const path = `${prefix}/${manifestItem.path}`;
-    return {
-      name: manifestItem.name,
-      path: path,
-      absolutePath: path,
-      size: manifestItem.size,
-      modifiedTime: new Date(manifestItem.modifiedTime),
-      isDirectory: manifestItem.isDirectory,
-      contentType: manifestItem.contentType
-    };
-  }
-
-
-  private checkResponse(path: ENGINE.AssetPath, response: Response): void {
-    if (!response.ok) {
-      throw new Error(`Failed to fetch ${path.initialPath}: ${response.status} ${response.statusText}`);
-    }
-  }
-}
+import * as ENGINE from 'genesys.js';
+
+export type FileManifestItem = Omit<ENGINE.FileItem, 'absolutePath'>;
+
+export const ManifestPath = 'dist/file-manifest.json';
+
+export interface FileManifest {
+  generated: string;
+  projectFiles: Record<string, FileManifestItem[]>;
+  engineFiles: Record<string, FileManifestItem[]>;
+}
+
+export class DevStorageProvider implements ENGINE.IStorageProvider {
+  private manifestCache: FileManifest | null = null;
+  private manifestPromise: Promise<FileManifest> | null = null;
+
+  private async loadManifest(): Promise<FileManifest> {
+    if (this.manifestCache) {
+      return this.manifestCache;
+    }
+
+    if (this.manifestPromise) {
+      return this.manifestPromise;
+    }
+
+    this.manifestPromise = this.fetchManifest();
+    this.manifestCache = await this.manifestPromise;
+    this.manifestPromise = null;
+
+    return this.manifestCache;
+  }
+
+  private async fetchManifest(): Promise<FileManifest> {
+    try {
+      const response = await fetch(`/${ManifestPath}`);
+      if (!response.ok) {
+        throw new Error(`Failed to load manifest: ${response.status} ${response.statusText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      console.warn('Failed to load file manifest, falling back to empty manifest:', error);
+      return {
+        generated: new Date().toISOString(),
+        projectFiles: {},
+        engineFiles: {}
+      };
+    }
+  }
+
+  async resolvePath(path: ENGINE.AssetPath, expiry?: number): Promise<ENGINE.AssetPath> {
+    if (path.isResolved()) {
+      return path;
+    }
+
+    let resolvedUrl: string;
+
+    if (path.initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+      resolvedUrl = path.initialPath.replace(ENGINE.PROJECT_PATH_PREFIX, ENGINE.BUILT_PROJECT_FOLDER);
+    } else if (path.initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX)) {
+      resolvedUrl = path.initialPath.replace(ENGINE.ENGINE_PATH_PREFIX, '/node_modules/genesys.js');
+    } else if (path.initialPath.startsWith('/')) {
+      resolvedUrl = `/node_modules/genesys.js${path.initialPath}`;
+    } else if (path.initialPath.startsWith('http') || path.initialPath.startsWith('https')) {
+      resolvedUrl = path.initialPath;
+    } else {
+      // Paths without prefix are treated as engine paths
+      resolvedUrl = `/node_modules/genesys.js/${path.initialPath}`;
+    }
+
+    path.resolvePath(resolvedUrl, ENGINE.AssetPathEncodeState.Unknown);
+    return path;
+  }
+
+  async downloadFileAsBuffer(path: ENGINE.AssetPath): Promise<ArrayBuffer> {
+    const resolvedPath = await this.resolvePath(path);
+    const response = await fetch(resolvedPath.getResolvedPath());
+    this.checkResponse(path, response);
+    return response.arrayBuffer();
+  }
+
+  async downloadFileAsJson<T>(path: ENGINE.AssetPath): Promise<T> {
+    const resolvedPath = await this.resolvePath(path);
+    const response = await fetch(resolvedPath.getResolvedPath());
+    this.checkResponse(path, response);
+    return response.json();
+  }
+
+  async downloadFileAsText(path: ENGINE.AssetPath): Promise<string> {
+    const resolvedPath = await this.resolvePath(path);
+    const response = await fetch(resolvedPath.getResolvedPath());
+    this.checkResponse(path, response);
+    return response.text();
+  }
+
+  async uploadFile(
+    path: ENGINE.AssetPath,
+    content: Blob | File | string | ArrayBuffer,
+    options?: ENGINE.FileUploadOptions
+  ): Promise<{ path: string; name: string }> {
+    throw new Error('ViteDevStorageProvider does not support uploading files.');
+  }
+
+  async listFiles(
+    path: ENGINE.AssetPath,
+    recursive?: boolean,
+    includeHiddenFiles?: boolean
+  ): Promise<ENGINE.FileListResult> {
+    try {
+      const manifest = await this.loadManifest();
+      const initialPath = path.initialPath;
+      const targetPath = this.normalizePathForManifest(initialPath);
+
+      // Determine which file collection to use
+      // Paths without prefix are treated as engine assets
+      const isEngineAsset = initialPath.startsWith(ENGINE.ENGINE_PATH_PREFIX);
+      const isProjectAsset = initialPath.startsWith(ENGINE.PROJECT_PATH_PREFIX);
+      if (!isEngineAsset && !isProjectAsset) {
+        throw new Error(`Invalid path: ${path}`);
+      }
+      const fileCollection = isEngineAsset ? manifest.engineFiles : manifest.projectFiles;
+
+      const files: ENGINE.FileItem[] = [];
+      const directories: ENGINE.FileItem[] = [];
+
+      if (recursive) {
+        // For recursive listing, include all files that start with the target path
+        for (const [dirPath, items] of Object.entries(fileCollection)) {
+          if (dirPath === targetPath || dirPath.startsWith(targetPath + '/') || (targetPath === '' && !dirPath.includes('/'))) {
+            for (const item of items) {
+              const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
+
+              if (!includeHiddenFiles && item.name.startsWith('.')) {
+                continue;
+              }
+
+              if (item.isDirectory) {
+                directories.push(engineFileItem);
+              } else {
+                files.push(engineFileItem);
+              }
+            }
+          }
+        }
+      } else {
+        // For non-recursive listing, only include direct children
+        const directItems = fileCollection[targetPath] || [];
+
+        for (const item of directItems) {
+          const engineFileItem = this.convertToEngineFileItem(item, isEngineAsset);
+
+          if (!includeHiddenFiles && item.name.startsWith('.')) {
+            continue;
+          }
+
+          // Only include direct children (not nested)
+          const itemDirPath = item.path.substring(0, item.path.lastIndexOf('/'));
+          const normalizedItemDirPath = itemDirPath === '.' || itemDirPath === '' ? '' : itemDirPath;
+
+          if (normalizedItemDirPath === targetPath) {
+            if (item.isDirectory) {
+              directories.push(engineFileItem);
+            } else {
+              files.push(engineFileItem);
+            }
+          }
+        }
+      }
+
+      return { files, directories };
+    } catch (error) {
+      console.warn(`Failed to list files for path ${path.initialPath}:`, error);
+      return { files: [], directories: [] };
+    }
+  }
+
+  async exists(path: ENGINE.AssetPath): Promise<boolean> {
+    try {
+      const resolvedPath = await this.resolvePath(path);
+      const response = await fetch(resolvedPath.getResolvedPath(), { method: 'HEAD' });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+
+  async buildCurrentProject(runTsc: boolean): Promise<boolean> {
+    // For development, we don't need to build the project
+    // Vite handles the compilation
+    return true;
+  }
+
+  private normalizePathForManifest(pathStr: string): string {
+    // Remove @project/ or @engine/ prefix
+    let normalized = pathStr.replace(ENGINE.PROJECT_PATH_PREFIX, '').replace(ENGINE.ENGINE_PATH_PREFIX, '');
+
+    // Remove leading slash if present
+    if (normalized.startsWith('/')) {
+      normalized = normalized.substring(1);
+    }
+
+    // Remove trailing slash if present
+    if (normalized.endsWith('/')) {
+      normalized = normalized.substring(0, normalized.length - 1);
+    }
+
+    return normalized;
+  }
+
+  private convertToEngineFileItem(manifestItem: FileManifestItem, isEngineAsset: boolean): ENGINE.FileItem {
+    const prefix = isEngineAsset ? ENGINE.ENGINE_PATH_PREFIX : ENGINE.PROJECT_PATH_PREFIX;
+    const path = `${prefix}/${manifestItem.path}`;
+    return {
+      name: manifestItem.name,
+      path: path,
+      absolutePath: path,
+      size: manifestItem.size,
+      modifiedTime: new Date(manifestItem.modifiedTime),
+      isDirectory: manifestItem.isDirectory,
+      contentType: manifestItem.contentType
+    };
+  }
+
+
+  private checkResponse(path: ENGINE.AssetPath, response: Response): void {
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path.initialPath}: ${response.status} ${response.statusText}`);
+    }
+  }
+}

package/src/templates/scripts/genesys/dev/update-template-scenes.ts

@@ -1,84 +1,84 @@
-import fs from 'fs';
-import path from 'path';
-
-import { SCENE_EXTENSION } from '../const.js';
-import { loadWorld } from '../mcp/utils.js';
-import { mockBrowserEnvironment } from '../mock.js';
-
-// Mock browser environment as required by the engine
-mockBrowserEnvironment();
-
-async function findGenesysSceneFiles(dir: string): Promise<string[]> {
-  const sceneFiles: string[] = [];
-
-  try {
-    const items = fs.readdirSync(dir, { withFileTypes: true });
-
-    for (const item of items) {
-      const fullPath = path.join(dir, item.name);
-
-      if (item.isDirectory()) {
-        // Recursively search subdirectories
-        const subFiles = await findGenesysSceneFiles(fullPath);
-        sceneFiles.push(...subFiles);
-      } else if (item.isFile() && item.name.endsWith(SCENE_EXTENSION)) {
-        sceneFiles.push(fullPath);
-      }
-    }
-  } catch (error) {
-    console.error(`Error reading directory ${dir}:`, error);
-  }
-
-  return sceneFiles;
-}
-
-async function updateSceneFile(sceneFilePath: string): Promise<void> {
-  console.log(`Processing: ${sceneFilePath}`);
-
-  try {
-    // Use the loadWorld utility with proper disposal using 'using' keyword
-    using worldResource = await loadWorld(sceneFilePath, {
-      readonly: false, // Allow saving changes
-      skipLoadingGLTF: true // Skip GLTF loading for faster processing
-    });
-
-    console.log(`✓ Successfully updated: ${sceneFilePath}`);
-  } catch (error) {
-    console.error(`✗ Failed to update ${sceneFilePath}:`, error);
-  }
-}
-
-async function main() {
-  console.log('Searching for .genesys-scene files in src folder...');
-
-  const srcDir = path.join(process.cwd(), 'src');
-
-  if (!fs.existsSync(srcDir)) {
-    console.error('src directory not found');
-    return;
-  }
-
-  const sceneFiles = await findGenesysSceneFiles(srcDir);
-
-  if (sceneFiles.length === 0) {
-    console.log('No .genesys-scene files found in src folder');
-    return;
-  }
-
-  console.log(`Found ${sceneFiles.length} .genesys-scene files:`);
-  sceneFiles.forEach(file => console.log(`  - ${path.relative(process.cwd(), file)}`));
-
-  console.log('\nUpdating scene files...');
-
-  // Process each scene file
-  for (const sceneFile of sceneFiles) {
-    await updateSceneFile(sceneFile);
-  }
-
-  console.log('\nScene update process completed!');
-}
-
-main().catch(error => {
-  console.error('Script failed:', error);
-  process.exit(1);
-});
+import fs from 'fs';
+import path from 'path';
+
+import { SCENE_EXTENSION } from '../const.js';
+import { loadWorld } from '../mcp/utils.js';
+import { mockBrowserEnvironment } from '../mock.js';
+
+// Mock browser environment as required by the engine
+mockBrowserEnvironment();
+
+async function findGenesysSceneFiles(dir: string): Promise<string[]> {
+  const sceneFiles: string[] = [];
+
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const item of items) {
+      const fullPath = path.join(dir, item.name);
+
+      if (item.isDirectory()) {
+        // Recursively search subdirectories
+        const subFiles = await findGenesysSceneFiles(fullPath);
+        sceneFiles.push(...subFiles);
+      } else if (item.isFile() && item.name.endsWith(SCENE_EXTENSION)) {
+        sceneFiles.push(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading directory ${dir}:`, error);
+  }
+
+  return sceneFiles;
+}
+
+async function updateSceneFile(sceneFilePath: string): Promise<void> {
+  console.log(`Processing: ${sceneFilePath}`);
+
+  try {
+    // Use the loadWorld utility with proper disposal using 'using' keyword
+    using worldResource = await loadWorld(sceneFilePath, {
+      readonly: false, // Allow saving changes
+      skipLoadingGLTF: true // Skip GLTF loading for faster processing
+    });
+
+    console.log(`✓ Successfully updated: ${sceneFilePath}`);
+  } catch (error) {
+    console.error(`✗ Failed to update ${sceneFilePath}:`, error);
+  }
+}
+
+async function main() {
+  console.log('Searching for .genesys-scene files in src folder...');
+
+  const srcDir = path.join(process.cwd(), 'src');
+
+  if (!fs.existsSync(srcDir)) {
+    console.error('src directory not found');
+    return;
+  }
+
+  const sceneFiles = await findGenesysSceneFiles(srcDir);
+
+  if (sceneFiles.length === 0) {
+    console.log('No .genesys-scene files found in src folder');
+    return;
+  }
+
+  console.log(`Found ${sceneFiles.length} .genesys-scene files:`);
+  sceneFiles.forEach(file => console.log(`  - ${path.relative(process.cwd(), file)}`));
+
+  console.log('\nUpdating scene files...');
+
+  // Process each scene file
+  for (const sceneFile of sceneFiles) {
+    await updateSceneFile(sceneFile);
+  }
+
+  console.log('\nScene update process completed!');
+}
+
+main().catch(error => {
+  console.error('Script failed:', error);
+  process.exit(1);
+});

package/src/templates/scripts/genesys/doc-server.ts

@@ -1,16 +1,16 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-
-import { addDocTools } from './mcp/doc-tools.js';
-
-// Create an MCP server
-const server = new McpServer({
-  name: 'Genesys-Doc-Server',
-  version: '0.0.1'
-});
-
-addDocTools(server);
-
-// Start receiving messages on stdin and sending messages on stdout
-const transport = new StdioServerTransport();
-await server.connect(transport);
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+
+import { addDocTools } from './mcp/doc-tools.js';
+
+// Create an MCP server
+const server = new McpServer({
+  name: 'Genesys-Doc-Server',
+  version: '0.0.1'
+});
+
+addDocTools(server);
+
+// Start receiving messages on stdin and sending messages on stdout
+const transport = new StdioServerTransport();
+await server.connect(transport);