@directivegames/genesys.sdk 3.2.2

package/dist/src/core/tools/build-project.js

@@ -0,0 +1,450 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import { findFilesByPredicate, getProjectFolderAndFile, runCommandAsync } from '../index.js';
+function getTscBinaryPath(projectFolder, logger) {
+    // Look in the project's node_modules for tsc
+    const projectBinaryPath = path.join(projectFolder, 'node_modules', '.bin', process.platform === 'win32' ? 'tsc.cmd' : 'tsc');
+    if (fs.existsSync(projectBinaryPath)) {
+        logger.log(`Found tsc binary at: ${projectBinaryPath}`);
+        return projectBinaryPath;
+    }
+    // Fallback to pnpm exec
+    logger.log('tsc not found in project node_modules, using pnpm exec');
+    return 'pnpm exec tsc';
+}
+function getEsbuildBinaryPath(projectFolder, logger, isPackaged, resourcesPath) {
+    // In packaged app, esbuild binary is in app.asar.unpacked
+    if (isPackaged) {
+        const platform = process.platform;
+        const arch = process.arch;
+        // Construct the platform-specific binary path
+        let binaryName = 'esbuild';
+        let platformFolder = '';
+        if (platform === 'win32') {
+            binaryName = 'esbuild.exe';
+            platformFolder = `win32-${arch}`;
+        }
+        else if (platform === 'darwin') {
+            platformFolder = `darwin-${arch}`;
+        }
+        else if (platform === 'linux') {
+            platformFolder = `linux-${arch}`;
+        }
+        // Try to find the binary in app.asar.unpacked
+        const unpackedPath = path.join(resourcesPath, 'app.asar.unpacked', 'node_modules', '@esbuild', platformFolder, binaryName);
+        if (fs.existsSync(unpackedPath)) {
+            logger.log(`Found esbuild binary at: ${unpackedPath}`);
+            return unpackedPath;
+        }
+        logger.warn('esbuild binary not found in app.asar.unpacked, trying SDK\'s node_modules');
+    }
+    // In dev mode or as fallback, look in the project's node_modules
+    const projectBinaryPath = path.join(projectFolder, 'node_modules', '.bin', process.platform === 'win32' ? 'esbuild.cmd' : 'esbuild');
+    if (fs.existsSync(projectBinaryPath)) {
+        logger.log(`Found esbuild binary in project at: ${projectBinaryPath}`);
+        return projectBinaryPath;
+    }
+    // When running as CLI (not packaged), also check the SDK's own node_modules
+    // resourcesPath points to the SDK root in CLI mode
+    const sdkBinaryPath = path.join(resourcesPath, 'node_modules', '.bin', process.platform === 'win32' ? 'esbuild.cmd' : 'esbuild');
+    if (fs.existsSync(sdkBinaryPath)) {
+        logger.log(`Found esbuild binary in SDK at: ${sdkBinaryPath}`);
+        return sdkBinaryPath;
+    }
+    // Last resort - use pnpm dlx
+    return 'pnpm dlx esbuild';
+}
+function gatherAssets(data) {
+    const assets = [];
+    for (const [k, v] of Object.entries(data)) {
+        if (typeof v === 'string' && v.startsWith(ENGINE.PROJECT_PATH_PREFIX)) {
+            assets.push(v);
+        }
+        if (typeof v === 'object' && v !== null) {
+            assets.push(...gatherAssets(v));
+        }
+    }
+    return assets;
+}
+export function findFilesWithExtension(dir, extension) {
+    // Normalize extension (ensure it starts with dot)
+    const ext = extension.startsWith('.') ? extension : `.${extension}`;
+    let results = [];
+    const files = fs.readdirSync(dir);
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        if (stat.isDirectory()) {
+            results = results.concat(findFilesWithExtension(filePath, ext));
+        }
+        else if (filePath.endsWith(ext)) {
+            results.push(filePath);
+        }
+    }
+    return results;
+}
+async function copyAssets(projectPath, distFolder, alwaysCopyAssets, logger) {
+    try {
+        // Find all files that can contain asset paths in distFolder
+        const beginTime = Date.now();
+        const jsonFiles = findFilesWithExtension(distFolder, 'json');
+        const jsFiles = findFilesWithExtension(distFolder, 'js');
+        const htmlFiles = findFilesWithExtension(distFolder, 'html');
+        const cssFiles = findFilesWithExtension(distFolder, 'css');
+        const sceneFiles = findFilesWithExtension(distFolder, ENGINE.SCENE_NAME_EXT);
+        const durationSec = (Date.now() - beginTime) / 1000;
+        logger.log(`Stats: findFilesWithExtension done in ${durationSec}s`);
+        const assets = new Set();
+        const processedAssets = new Set();
+        // include the scene files in the json files
+        jsonFiles.push(...sceneFiles);
+        // Add always copy assets
+        for (const asset of alwaysCopyAssets) {
+            let sourceAssetPath = asset;
+            const withProjectPrefix = asset.startsWith(ENGINE.PROJECT_PATH_PREFIX);
+            if (withProjectPrefix) {
+                sourceAssetPath = asset.replace(ENGINE.PROJECT_PATH_PREFIX, projectPath);
+            }
+            else if (!path.isAbsolute(asset)) {
+                sourceAssetPath = path.join(projectPath, asset);
+            }
+            logger.log('Handling alwaysCopyAssets entry:', asset, sourceAssetPath);
+            if (fs.statSync(sourceAssetPath).isDirectory()) {
+                // If it's a directory, add all files in it
+                const files = findFilesByPredicate(sourceAssetPath, () => true);
+                for (const file of files) {
+                    const relativePath = path.relative(projectPath, file).replace(/\\/g, '/');
+                    assets.add(`${ENGINE.PROJECT_PATH_PREFIX}/${relativePath}`);
+                }
+                logger.log(`Added ${files.length} files from alwaysCopyAssets directory ${sourceAssetPath}`);
+            }
+            else {
+                if (!withProjectPrefix) {
+                    assets.add(`${ENGINE.PROJECT_PATH_PREFIX}/${path.relative(projectPath, sourceAssetPath).replace(/\\/g, '/')}`);
+                }
+                else {
+                    assets.add(asset);
+                }
+            }
+        }
+        // Helper function to discover assets from a file
+        async function discoverAssetsFromFile(filePath) {
+            const discoveredAssets = [];
+            try {
+                if (filePath.endsWith('.json') || filePath.includes(ENGINE.SCENE_NAME_EXT)) {
+                    const jsonData = JSON.parse(await fs.promises.readFile(filePath, 'utf8'));
+                    discoveredAssets.push(...gatherAssets(jsonData));
+                }
+                else if (filePath.endsWith('.js')) {
+                    const regex = new RegExp(String.raw `(["'])${ENGINE.PROJECT_PATH_PREFIX}\/.*?\1`, 'g');
+                    const jsData = await fs.promises.readFile(filePath, 'utf8');
+                    const matches = jsData.matchAll(regex);
+                    for (const match of matches) {
+                        discoveredAssets.push(match[0].replace(/["']/g, ''));
+                    }
+                }
+                else if (filePath.endsWith('.html') || filePath.endsWith('.css')) {
+                    // For HTML and CSS files, look for asset paths in various contexts
+                    const regex = new RegExp(String.raw `${ENGINE.PROJECT_PATH_PREFIX}\/[^"'\s)]+`, 'g');
+                    const fileData = await fs.promises.readFile(filePath, 'utf8');
+                    const matches = fileData.matchAll(regex);
+                    for (const match of matches) {
+                        discoveredAssets.push(match[0]);
+                    }
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to read file ${filePath}: ${error}`);
+            }
+            return discoveredAssets;
+        }
+        // Recursively discover all assets
+        async function discoverAllAssets(initialFiles) {
+            const filesToProcess = [...initialFiles];
+            while (filesToProcess.length > 0) {
+                const currentFile = filesToProcess.shift();
+                if (processedAssets.has(currentFile)) {
+                    continue;
+                }
+                processedAssets.add(currentFile);
+                const discoveredAssets = await discoverAssetsFromFile(currentFile);
+                for (const asset of discoveredAssets) {
+                    if (!assets.has(asset)) {
+                        assets.add(asset);
+                        // Check if this asset is a file that might contain references to other assets
+                        const sourceAssetPath = asset.replace(ENGINE.PROJECT_PATH_PREFIX, projectPath);
+                        try {
+                            await fs.promises.access(sourceAssetPath);
+                            // Only process JSON, JS, HTML, CSS, and scene files that might contain asset references
+                            if (sourceAssetPath.endsWith('.json') ||
+                                sourceAssetPath.endsWith('.js') ||
+                                sourceAssetPath.endsWith('.html') ||
+                                sourceAssetPath.endsWith('.css') ||
+                                sourceAssetPath.includes(ENGINE.SCENE_NAME_EXT)) {
+                                filesToProcess.push(sourceAssetPath);
+                            }
+                        }
+                        catch {
+                            logger.error(`copyAssets: source asset ${asset} does not exist, referenced from ${currentFile}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Start discovery from initial files
+        {
+            const beginTime = Date.now();
+            await discoverAllAssets([...jsonFiles, ...jsFiles, ...htmlFiles, ...cssFiles]);
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.log(`Stats: Assets discovered in ${durationSec}s`);
+        }
+        /*
+        // Find and add lightmap files and navmesh files that may not be directly referenced
+        // Disabled for now, see https://directive.slack.com/archives/C08M839GVBP/p1755865316511099
+        try {
+          const beginTime = Date.now();
+          const engineFiles = [
+            ...findFilesWithExtension(projectPath, ENGINE.LIGHTMAP_JSON_EXT),
+            ...findFilesWithExtension(projectPath, ENGINE.LIGHTMAP_BIN_EXT),
+            ...findFilesWithExtension(projectPath, ENGINE.NAVMESH_EXT),
+          ];
+          for (const file of engineFiles) {
+            // Convert absolute path to @project relative path
+            const relativePath = path.relative(projectPath, file);
+            const assetPath = `${ENGINE.PROJECT_PATH_PREFIX}/${relativePath.replace(/\\/g, '/')}`;
+            assets.add(assetPath);
+            logger.log(`Found engine file: ${assetPath}`);
+          }
+          const durationSec = (Date.now() - beginTime) / 1000;
+          logger.log(`Stats: lightmap and navmesh files discovered in ${durationSec}s`);
+        } catch (error) {
+          logger.error(`Failed to scan for engine files: ${error}`);
+        }
+        */
+        // Copy all assets in parallel
+        const copyPromises = Array.from(assets).map(async (asset) => {
+            try {
+                const sourceAssetPath = asset.replace(ENGINE.PROJECT_PATH_PREFIX, projectPath);
+                // Check if source exists
+                try {
+                    await fs.promises.access(sourceAssetPath);
+                }
+                catch {
+                    // No need to log again here, it's already logged in the discoverAllAssets function
+                    return;
+                }
+                if (asset.includes(ENGINE.SCENE_NAME_EXT)) {
+                    // Do not copy the scene files since they have been minified and copied in an early step (see the buildProject function)
+                    // If we copy them again the minification will be undone
+                    // Also even if the copy is skipped the path map still needs to be set in order to have the correct scene file path in their referencers (for instance game.js)
+                    logger.verbose(`Skip copying ${sourceAssetPath} as it's been minified and copied in an early step`);
+                }
+                else if (fs.statSync(sourceAssetPath).isDirectory()) {
+                    // directory, skip it
+                }
+                else {
+                    const destinationAssetPath = asset.replace(ENGINE.PROJECT_PATH_PREFIX, distFolder);
+                    logger.verbose(`Copying ${sourceAssetPath} to ${destinationAssetPath}`);
+                    await fs.promises.mkdir(path.dirname(destinationAssetPath), { recursive: true });
+                    await fs.promises.copyFile(sourceAssetPath, destinationAssetPath);
+                }
+            }
+            catch (error) {
+                logger.error(`Failed to copy asset ${asset}: ${error}`);
+            }
+        });
+        {
+            const beginTime = Date.now();
+            await Promise.all(copyPromises);
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.verbose(`Stats: Assets copied in ${durationSec}s`);
+        }
+        // Collect all files that need path updates (initial dist files + copied asset files that can contain references)
+        const filesToUpdate = [...jsonFiles, ...jsFiles, ...htmlFiles, ...cssFiles];
+        // Add copied asset files that might contain asset references
+        for (const asset of assets) {
+            const destinationAssetPath = asset.replace(ENGINE.PROJECT_PATH_PREFIX, distFolder);
+            if (destinationAssetPath.endsWith('.json') ||
+                destinationAssetPath.endsWith('.js') ||
+                destinationAssetPath.endsWith('.html') ||
+                destinationAssetPath.endsWith('.css') ||
+                destinationAssetPath.includes(ENGINE.SCENE_NAME_EXT)) {
+                filesToUpdate.push(destinationAssetPath);
+            }
+        }
+    }
+    catch (error) {
+        logger.error(`Failed to copy assets: ${error}`);
+        throw error;
+    }
+}
+function buildSceneData(sceneData) {
+    function removeEditorData(data) {
+        if (typeof data === 'object' && data !== null) {
+            delete data.editorData;
+            for (const v of Object.values(data)) {
+                removeEditorData(v);
+            }
+        }
+    }
+    removeEditorData(sceneData);
+    return sceneData;
+}
+export async function buildProject(projectPath, runTsc, logger, handler) {
+    const { folder: projectFolder, file: projectFile } = getProjectFolderAndFile(projectPath, logger);
+    try {
+        logger.log(`Building project at ${projectPath}`);
+        if (!fs.existsSync(projectFolder)) {
+            return {
+                success: false,
+                message: `Project does not exist: ${projectPath}`,
+                path: projectPath
+            };
+        }
+        const sourceFolder = path.join(projectFolder, 'src');
+        const excludedFolders = ['node_modules', '.git'];
+        const gameFiles = findFilesByPredicate(sourceFolder, (filePath) => path.basename(filePath) === ENGINE.DEFAULT_GAME_NAME && !filePath.includes(ENGINE.BUILT_PROJECT_FOLDER), excludedFolders);
+        const sceneFiles = findFilesByPredicate(projectFolder, (filePath) => path.basename(filePath).includes(ENGINE.SCENE_NAME_EXT) && !filePath.includes(ENGINE.BUILT_PROJECT_FOLDER), excludedFolders);
+        if (!gameFiles.length) {
+            return {
+                success: false,
+                message: `Game file ${ENGINE.DEFAULT_GAME_NAME} does not exist`,
+                path: projectPath
+            };
+        }
+        if (gameFiles.length > 1) {
+            return {
+                success: false,
+                message: `Multiple game files found: ${gameFiles.join(', ')}`,
+                path: projectPath
+            };
+        }
+        if (!projectFile) {
+            return {
+                success: false,
+                message: `Project file ${ENGINE.GAME_PROJECT_FILE_EXT} does not exist`,
+                path: projectPath
+            };
+        }
+        const autoImportPath = path.join(sourceFolder, 'auto-imports.ts');
+        if (fs.existsSync(autoImportPath)) {
+            let importText = '';
+            const sourceFiles = findFilesWithExtension(sourceFolder, 'ts');
+            for (const sourceFile of sourceFiles) {
+                if (sourceFile.includes('auto-imports.ts')) {
+                    continue;
+                }
+                if (sourceFile.includes(ENGINE.DEFAULT_GAME_NAME)) {
+                    continue;
+                }
+                const importPath = path.relative(sourceFolder, sourceFile).replaceAll('\\', '/');
+                importText += `import './${importPath}';\n`;
+            }
+            fs.writeFileSync(autoImportPath, importText);
+        }
+        else {
+            logger.warn(`Auto-imports file ${autoImportPath} does not exist`);
+        }
+        const distFolder = path.join(projectFolder, ENGINE.BUILT_PROJECT_FOLDER);
+        if (fs.existsSync(distFolder)) {
+            const beginTime = Date.now();
+            fs.rmSync(distFolder, { recursive: true });
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.log(`Stats: Dist folder removed in ${durationSec}s`);
+        }
+        fs.mkdirSync(distFolder, { recursive: true });
+        if (runTsc) {
+            logger.log('Running TypeScript type checking');
+            const beginTime = Date.now();
+            // Get the direct path to tsc binary (avoids pnpm exec overhead)
+            const tscBinary = getTscBinaryPath(projectFolder, logger);
+            // Build the command - quote the binary path only if it's not pnpm exec
+            const tscParameters = '--noEmit --incremental';
+            const tscCommand = tscBinary.startsWith('pnpm')
+                ? `${tscBinary} ${tscParameters}`
+                : `"${tscBinary}" ${tscParameters}`;
+            logger.log(`Using tsc: ${tscBinary}`);
+            // Only type check, don't emit files - esbuild will handle transpilation
+            // --incremental speeds up subsequent builds by caching results
+            await runCommandAsync(tscCommand, projectFolder, logger);
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.log(`Stats: TypeScript type checking completed in ${durationSec}s`);
+        }
+        {
+            const gameBundleFilePath = path.join(distFolder, ENGINE.DEFAULT_GAME_BUNDLE_NAME);
+            logger.log(`Building game bundle from ${gameFiles[0]}`);
+            const beginTime = Date.now();
+            // Get the direct path to esbuild binary (avoids pnpm exec overhead)
+            const esbuildBinary = getEsbuildBinaryPath(projectFolder, logger, handler.app.isPackaged, handler.app.resourcesPath);
+            // Build the command - quote the binary path only if it's not pnpm exec
+            const buildParameters = `--bundle --platform=browser --minify --keep-names --outfile="${gameBundleFilePath}" --external:genesys.js --external:three --format=cjs`;
+            const buildCommand = esbuildBinary.startsWith('pnpm')
+                ? `${esbuildBinary} "${gameFiles[0]}" ${buildParameters}`
+                : `"${esbuildBinary}" "${gameFiles[0]}" ${buildParameters}`;
+            logger.log(`Using esbuild: ${esbuildBinary}`);
+            const { error, stdout, stderr } = await runCommandAsync(buildCommand, projectFolder, logger);
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.log(`Stats: Game bundle built in ${durationSec}s`);
+            if (error && error.code !== 0) {
+                await handler.ui.showErrorDialog('Failed to build project', stderr);
+                throw new Error(`Building game bundle failed: ${stderr || error.message}`);
+            }
+        }
+        // inject the prefabs into the scene
+        for (const sceneFile of sceneFiles) {
+            const sceneData = JSON.parse(fs.readFileSync(sceneFile, 'utf8'));
+            if (!sceneData.$version || sceneData.$version < ENGINE.SerializationVersion.V1) {
+                sceneData.prefabs = {};
+                for (const actor of sceneData.actors) {
+                    const prefabName = actor.prefabName;
+                    if (prefabName) {
+                        const prefabPath = prefabName.replace(ENGINE.PROJECT_PATH_PREFIX, projectFolder);
+                        if (!fs.existsSync(prefabPath)) {
+                            throw new Error(`Prefab ${prefabPath} does not exist`);
+                        }
+                        const prefabData = JSON.parse(fs.readFileSync(prefabPath, 'utf8'));
+                        sceneData.prefabs[prefabName] = prefabData;
+                    }
+                }
+            }
+            const relativePath = path.relative(projectFolder, sceneFile);
+            const sceneDestinationPath = path.join(distFolder, relativePath);
+            fs.mkdirSync(path.dirname(sceneDestinationPath), { recursive: true });
+            fs.writeFileSync(sceneDestinationPath, JSON.stringify(buildSceneData(sceneData)));
+        }
+        // copy the project file to the dist folder
+        fs.copyFileSync(path.join(projectFolder, projectFile), path.join(distFolder, projectFile));
+        const projectConfig = JSON.parse(fs.readFileSync(path.join(projectFolder, projectFile), 'utf8'));
+        {
+            const beginTime = Date.now();
+            const alwaysCopyAssets = [];
+            if (Array.isArray(projectConfig.alwaysCopyAssets)) {
+                alwaysCopyAssets.push(...projectConfig.alwaysCopyAssets);
+            }
+            else if (typeof projectConfig.alwaysCopyAssets === 'string') {
+                alwaysCopyAssets.push(projectConfig.alwaysCopyAssets);
+            }
+            else {
+                logger.warn('project.json alwaysCopyAssets is not an array or string');
+            }
+            await copyAssets(projectFolder, distFolder, alwaysCopyAssets, logger);
+            const durationSec = (Date.now() - beginTime) / 1000;
+            logger.log(`Stats: copyAssets done in ${durationSec}s`);
+        }
+        logger.log(`Project built successfully at ${distFolder}`);
+        return {
+            success: true,
+            message: `Project built successfully at ${distFolder}`,
+            path: projectPath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to build project: ${error}`,
+            path: projectPath,
+            error: error,
+        };
+    }
+}

package/dist/src/core/tools/index.js

@@ -0,0 +1,2 @@
+export * from './new-project.js';
+export * from './new-asset-pack.js';

package/dist/src/core/tools/new-asset-pack.js

@@ -0,0 +1,150 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import { ALL_DEPENDENCIES } from '../../dependencies.js';
+import { copyAsync, existsAsync, getEngineVersion, getProjectRoot, mkdirAsync, readdirAsync, runCommandAsync, writeFileAsync } from '../common.js';
+import { IgnoredFiles } from '../index.js';
+export const packProjectFiles = {
+    packageJson: {
+        name: '',
+        version: '0.0.1',
+        scripts: {
+            'build': 'tsc',
+            'pack': 'pnpm build && pnpm pack',
+            'lint': 'eslint . --fix --ext .ts,.tsx',
+            'postinstall': 'tsx scripts/postinstall.ts'
+        },
+        keywords: [],
+        type: 'module',
+        files: [
+            'dist',
+            'src',
+            'assets',
+            'scripts'
+        ],
+        main: 'dist/src/index.js',
+        peerDependencies: {
+            'genesys.js': `${getEngineVersion()}`,
+            'three': ALL_DEPENDENCIES['three'],
+        },
+        devDependencies: {
+            '@types/three': ALL_DEPENDENCIES['@types/three'],
+            'nanoid': ALL_DEPENDENCIES['nanoid'],
+            'ajv': ALL_DEPENDENCIES['ajv'],
+            'esbuild': ALL_DEPENDENCIES['esbuild'],
+            'canvas': '3.1.0',
+            'get-port': '7.1.0',
+            'zod-to-json-schema': '3.24.6',
+            'ws': '8.18.2',
+            '@types/node': '22.15.21',
+            '@types/jsdom': '21.1.7',
+            '@modelcontextprotocol/sdk': '1.22.0',
+            'tsx': '4.20.3', // pin the tsx version to avoid import issues of the @webxr-input-profiles/motion-controllers module in game projects
+            'zod': '3.24.4',
+            'jsdom': '26.1.0',
+            'typescript': '5.8.3',
+            '@typescript-eslint/parser': '8.29.1',
+            '@typescript-eslint/utils': '8.38.0',
+            'eslint': '9.24.0',
+            '@types/ws': '8.18.1',
+            'ts-morph': '26.0.0',
+        }
+    },
+    codeWorkspace: {
+        folders: [
+            {
+                path: '.'
+            }
+        ],
+        settings: {
+            ['editor.tabSize']: 2
+        }
+    }
+};
+export function getAssetPackTemplatePath(isPackaged, resourcesPath, projectRoot) {
+    const packageName = 'src/asset-pack';
+    if (isPackaged) {
+        return path.join(resourcesPath, 'vendor', packageName);
+    }
+    else {
+        return path.join(projectRoot, packageName);
+    }
+}
+export async function newAssetPack(parentPath, packName, logger, handler) {
+    const packPath = path.join(parentPath, packName);
+    // Validate pack name - only allow English characters, numbers, hyphens, underscores, and dots
+    const validNameRegex = /^[a-zA-Z0-9_.-]+$/;
+    if (!validNameRegex.test(packName)) {
+        return {
+            success: false,
+            message: `Invalid pack name "${packName}". Pack name can only contain English characters (a-z, A-Z), numbers (0-9), hyphens (-), underscores (_), and dots (.).`,
+            path: packPath
+        };
+    }
+    const createAssetPackMessage = `Creating asset pack at ${packPath}`;
+    logger.log(createAssetPackMessage);
+    handler?.ui.showLoadingOverlay(`Creating asset pack...\n${createAssetPackMessage}`);
+    try {
+        if (await existsAsync(packPath)) {
+            // Check if directory is empty
+            const files = (await readdirAsync(packPath)).filter(file => !IgnoredFiles.includes(file));
+            if (files.length > 0) {
+                return {
+                    success: false,
+                    message: `The directory ${packPath} already contains files. Please choose an empty directory.`,
+                    path: packPath
+                };
+            }
+        }
+        else {
+            await mkdirAsync(packPath, { recursive: true });
+        }
+        // create asset pack directories
+        logger.log('Creating asset pack directories...');
+        await Promise.all([
+            mkdirAsync(path.join(packPath, `${ENGINE.ASSETS_FOLDER}/models`), { recursive: true }),
+            mkdirAsync(path.join(packPath, `${ENGINE.ASSETS_FOLDER}/textures`), { recursive: true }),
+            mkdirAsync(path.join(packPath, `${ENGINE.ASSETS_FOLDER}/sounds`), { recursive: true })
+        ]);
+        const packageJson = { ...packProjectFiles.packageJson }; // Create a copy to avoid mutation
+        packageJson.name = packName;
+        // generate package.json and code-workspace file
+        logger.log('Generating package.json and code-workspace file...');
+        await Promise.all([
+            writeFileAsync(path.join(packPath, 'package.json'), JSON.stringify(packageJson, null, 2)),
+            writeFileAsync(path.join(packPath, `${packName}.code-workspace`), JSON.stringify(packProjectFiles.codeWorkspace, null, 2)),
+        ]);
+        // Copy template files
+        logger.log('Copying template files...');
+        const templatePath = getAssetPackTemplatePath(handler.app.isPackaged, handler.app.resourcesPath, getProjectRoot());
+        await copyAsync(templatePath, packPath, { recursive: true });
+        // Rename gitignore to .gitignore (npm excludes .gitignore files from packages)
+        const gitignoreSrc = path.join(packPath, 'gitignore');
+        const gitignoreDst = path.join(packPath, '.gitignore');
+        if (await existsAsync(gitignoreSrc)) {
+            await fs.promises.rename(gitignoreSrc, gitignoreDst);
+        }
+        // install dependencies
+        logger.log('Running pnpm install...');
+        await runCommandAsync('pnpm install', packPath, logger);
+        // build asset pack
+        logger.log('Running pnpm build...');
+        await runCommandAsync('pnpm build', packPath, logger);
+        // open the asset pack in the file explorer
+        handler?.os.openPath(packPath);
+        logger.log('Asset pack created successfully');
+        return {
+            success: true,
+            message: `Asset pack created successfully at ${packPath}`,
+            path: packPath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to create asset pack: ${error}`,
+            path: packPath,
+            error: error,
+        };
+    }
+}