@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,292 @@
+import fs from 'fs';
+import path from 'path';
+import * as ENGINE from 'genesys.js';
+import { ALL_DEPENDENCIES } from '../../dependencies.js';
+import { deletedTemplateItems, sharedTemplateItems } from '../../templates/src/index.js';
+import { copyAsync, existsAsync, getEngineVersion, getProjectRoot, mkdirAsync, readdirAsync, runCommandAsync, writeFileAsync } from '../common.js';
+import { IgnoredFiles } from '../index.js';
+// Available project templates
+export const TEMPLATES = [
+    { id: 'fps', name: 'FPS', path: 'src/templates/fps', description: 'First person shooter template' },
+    { id: 'freeCamera', name: 'Free Camera Movement', path: 'src/templates/freeCamera', description: 'Free Camera Movement template' },
+    { id: 'firstPerson', name: '1st Person Movement', path: 'src/templates/firstPerson', description: '1st Person Movement template' },
+    { id: 'thirdPerson', name: '3rd Person Movement', path: 'src/templates/thirdPerson', description: '3rd Person Movement template' },
+    { id: 'sideScroller', name: 'Side Scroller', path: 'src/templates/sideScroller', description: 'Side Scroller template' },
+    { id: 'vehicle', name: 'Vehicle', path: 'src/templates/vehicle', description: 'Vehicle template' },
+    { id: 'vrGame', name: 'VR Game', path: 'src/templates/vr-game', description: 'VR Game template' },
+];
+export const projectFiles = {
+    packageJson: {
+        name: '',
+        version: '0.0.1',
+        scripts: {
+            'build': 'tsc',
+            'build-project': 'pnpm exec tsx ./scripts/genesys/build-project.ts',
+            'postinstall': 'pnpm exec tsx ./scripts/genesys/post-install.ts',
+            'lint': 'eslint . --fix --ext .ts,.tsx',
+            'remove-engine-comments': 'pnpm exec tsx ./scripts/genesys/remove-engine-comments.ts',
+            'dev': 'pnpm exec tsx ./scripts/genesys/dev/generate-manifest.ts && vite',
+            'validate-prefabs': 'pnpm exec tsx ./scripts/genesys/validate-prefabs.ts',
+        },
+        keywords: [],
+        type: 'module',
+        dependencies: {
+            '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',
+            'vite': '7.1.7',
+            'vite-plugin-mkcert': '1.17.8',
+            'vite-plugin-node-polyfills': '0.24.0',
+            '@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: '.'
+            },
+            {
+                path: './.engine'
+            }
+        ],
+        settings: {
+            ['editor.tabSize']: 2
+        }
+    },
+    genesysProject: {
+        [ENGINE.DEFAULT_SCENE_KEY]: `./${ENGINE.ASSETS_FOLDER}/default${ENGINE.SCENE_NAME_EXT}`,
+        [ENGINE.DEFAULT_EDITOR_SCENE_KEY]: `./${ENGINE.ASSETS_FOLDER}/default${ENGINE.SCENE_NAME_EXT}`,
+        [ENGINE.ENGINE_VERSION_KEY]: getEngineVersion()
+    }
+};
+export function getTemplatePath(isPackaged, resourcesPath, projectRoot) {
+    const packageName = 'src/templates';
+    if (isPackaged) {
+        return path.join(resourcesPath, 'vendor', packageName);
+    }
+    else {
+        return path.join(projectRoot, packageName);
+    }
+}
+export async function copySharedTemplateToProject(projectPath, templatePackagePath, logger) {
+    for (const sharedTemplateItem of sharedTemplateItems) {
+        const sourcePath = path.join(templatePackagePath, sharedTemplateItem);
+        // gitignore is renamed to .gitignore when copied to the project
+        // (npm excludes .gitignore files from packages)
+        const destinationName = sharedTemplateItem === 'gitignore' ? '.gitignore' : sharedTemplateItem;
+        const destinatePath = path.join(projectPath, destinationName);
+        if (!(await existsAsync(sourcePath))) {
+            logger.error(`${sourcePath} not found, skipping...`);
+            continue;
+        }
+        await copyAsync(sourcePath, destinatePath, { recursive: true });
+    }
+    for (const deletedTemplateItem of deletedTemplateItems) {
+        const filePath = path.join(projectPath, deletedTemplateItem);
+        if (await existsAsync(filePath)) {
+            await fs.promises.unlink(filePath);
+        }
+    }
+    // copy .gitignore to .npmignore, which is used by pnpm pack
+    const gitIgnorePath = path.join(projectPath, '.gitignore');
+    const npmIgnorePath = path.join(projectPath, '.npmignore');
+    await copyAsync(gitIgnorePath, npmIgnorePath);
+}
+export function getProjectNameFromPath(projectPath) {
+    return path.basename(projectPath).replace(' ', '-');
+}
+export function getGenesysProjectFile(projectPath) {
+    const projectName = getProjectNameFromPath(projectPath);
+    return path.join(projectPath, `${projectName}${ENGINE.GAME_PROJECT_FILE_EXT}`);
+}
+export async function createGenesysProjectFile(projectPath) {
+    const filePath = getGenesysProjectFile(projectPath);
+    if (await existsAsync(filePath)) {
+        return filePath;
+    }
+    await writeFileAsync(filePath, JSON.stringify(projectFiles.genesysProject, null, 2));
+    return filePath;
+}
+export async function migrateGenesysProjectFileForScenes(projectPath) {
+    const projectName = getProjectNameFromPath(projectPath);
+    const filePath = path.join(projectPath, `${projectName}${ENGINE.GAME_PROJECT_FILE_EXT}`);
+    if (await existsAsync(filePath)) {
+        // Migration logic would go here if needed
+    }
+}
+export async function newProject(parentPath, projectName, templateId, logger, handler) {
+    const projectPath = path.join(parentPath, projectName);
+    // Calculate template path using handler's app properties
+    const templatePackagePath = getTemplatePath(handler.app.isPackaged, handler.app.resourcesPath, getProjectRoot());
+    const template = TEMPLATES.find(t => t.id === templateId);
+    if (!template) {
+        return {
+            success: false,
+            message: `Template ${templateId} not found`,
+            path: projectPath
+        };
+    }
+    // Validate project name - only allow English characters, numbers, hyphens, underscores, and dots
+    const validNameRegex = /^[a-zA-Z0-9_.-]+$/;
+    if (!validNameRegex.test(projectName)) {
+        return {
+            success: false,
+            message: `Invalid project name "${projectName}". Project name can only contain English characters (a-z, A-Z), numbers (0-9), hyphens (-), underscores (_), and dots (.).`,
+            path: projectPath
+        };
+    }
+    const createProjectMessage = `Creating project at ${projectPath} using ${templateId} template`;
+    logger.log(createProjectMessage);
+    handler?.ui.showLoadingOverlay(`Creating project...\n${createProjectMessage}`);
+    try {
+        if (await existsAsync(projectPath)) {
+            // Check if directory is empty
+            const files = (await readdirAsync(projectPath)).filter(file => !IgnoredFiles.includes(file));
+            if (files.length > 0) {
+                return {
+                    success: false,
+                    message: `The directory ${projectPath} already contains files. Please choose an empty directory.`,
+                    path: projectPath
+                };
+            }
+        }
+        else {
+            await mkdirAsync(projectPath, { recursive: true });
+        }
+        // Overall project creation progress tracking
+        let overallProgress = 0;
+        const totalSteps = 5;
+        // Step 1: Creating directories (0-5%)
+        logger.log('Creating default scene and game code...');
+        handler?.ui.showLoadingOverlay('Creating project 0%\nStep 1/5 ▶ Creating directories...');
+        await new Promise(resolve => setTimeout(resolve, 300));
+        handler?.ui.showLoadingOverlay('Creating project 2%\nStep 1/5 ▶ Creating directories...');
+        await Promise.all([
+            mkdirAsync(path.join(projectPath, `${ENGINE.ASSETS_FOLDER}/models`), { recursive: true }),
+            mkdirAsync(path.join(projectPath, `${ENGINE.ASSETS_FOLDER}/textures`), { recursive: true }),
+            mkdirAsync(path.join(projectPath, `${ENGINE.ASSETS_FOLDER}/sounds`), { recursive: true })
+        ]);
+        overallProgress = 5;
+        handler?.ui.showLoadingOverlay('Creating project 5%\nStep 1/5 ▶ Directories created ✅');
+        await new Promise(resolve => setTimeout(resolve, 300));
+        // Step 2: Creating project files (5-10%)
+        logger.log('Creating project files...');
+        handler?.ui.showLoadingOverlay('Creating project 5%\nStep 2/5 ▶ Generating project files...');
+        await new Promise(resolve => setTimeout(resolve, 300));
+        const packageJson = { ...projectFiles.packageJson }; // Create a copy to avoid mutation
+        packageJson.name = projectName;
+        handler?.ui.showLoadingOverlay('Creating project 7%\nStep 2/5 ▶ Generating project files...');
+        const [, , projectFileFullPath] = await Promise.all([
+            writeFileAsync(path.join(projectPath, 'package.json'), JSON.stringify(packageJson, null, 2)),
+            writeFileAsync(path.join(projectPath, `${projectName}.code-workspace`), JSON.stringify(projectFiles.codeWorkspace, null, 2)),
+            createGenesysProjectFile(projectPath)
+        ]);
+        overallProgress = 8;
+        handler?.ui.showLoadingOverlay('Creating project 8%\nStep 2/5 ▶ Copying template files...');
+        // Copy template files
+        logger.log('Copying other project files...');
+        const individualTemplatePath = path.join(templatePackagePath, template.path);
+        await Promise.all([
+            copySharedTemplateToProject(projectPath, templatePackagePath, logger),
+            copyAsync(individualTemplatePath, projectPath, { recursive: true })
+        ]);
+        overallProgress = 10;
+        handler?.ui.showLoadingOverlay('Creating project 10%\nStep 2/5 ▶ Project files created ✅');
+        await new Promise(resolve => setTimeout(resolve, 300));
+        // Step 3: Installing dependencies (10-70%)
+        logger.log('Running pnpm install...');
+        handler?.ui.showLoadingOverlay('Creating project 10%\nStep 3/5 ▶ Installing dependencies...');
+        const installStartTime = Date.now();
+        const estimatedInstallTime = 35; // seconds
+        let installComplete = false;
+        let packageCount = '';
+        // Force UI updates every second with timer
+        const installInterval = setInterval(() => {
+            if (installComplete)
+                return;
+            const elapsed = (Date.now() - installStartTime) / 1000;
+            // Asymptotic progress: approaches 70% but never quite reaches it
+            const installProgress = Math.min(0.95, elapsed / estimatedInstallTime);
+            overallProgress = 10 + Math.floor(installProgress * 60);
+            handler?.ui.showLoadingOverlay(`Creating project ${overallProgress}%\nStep 3/5 ▶ Installing dependencies...`);
+        }, 1000);
+        await runCommandAsync('pnpm install', projectPath, logger, (progressMsg) => {
+            // Detect completion - pnpm uses different output format
+            if (progressMsg.match(/(\+|\d+) packages? in/i)) {
+                const countMatch = progressMsg.match(/(\d+) packages? in/i);
+                if (countMatch) {
+                    packageCount = countMatch[1];
+                }
+            }
+        });
+        installComplete = true;
+        clearInterval(installInterval);
+        overallProgress = 70;
+        handler?.ui.showLoadingOverlay(`Creating project 70%\nStep 3/5 ▶ Installed ${packageCount} packages ✅`);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Step 4: Building project (70-90%)
+        logger.log('Running pnpm build...');
+        handler?.ui.showLoadingOverlay('Creating project 70%\nStep 4/5 ▶ Building project...');
+        const buildStartTime = Date.now();
+        const estimatedBuildTime = 10; // seconds
+        let buildComplete = false;
+        // Force UI updates every second with timer
+        const buildInterval = setInterval(() => {
+            if (buildComplete)
+                return;
+            const elapsed = (Date.now() - buildStartTime) / 1000;
+            // Asymptotic progress: approaches 90% but never quite reaches it
+            const buildProgress = Math.min(0.95, elapsed / estimatedBuildTime);
+            overallProgress = 70 + Math.floor(buildProgress * 20);
+            handler?.ui.showLoadingOverlay(`Creating project ${overallProgress}%\nStep 4/5 ▶ Building project...`);
+        }, 1000);
+        await runCommandAsync('pnpm build', projectPath, logger);
+        buildComplete = true;
+        clearInterval(buildInterval);
+        overallProgress = 90;
+        handler?.ui.showLoadingOverlay('Creating project 90%\nStep 4/5 ▶ Build complete ✅');
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Step 5: Finalizing (90-100%)
+        handler?.ui.showLoadingOverlay('Creating project 95%\nStep 5/5 ▶ Finalizing...');
+        // open the project in the file explorer
+        handler?.os.openPath(projectPath);
+        await new Promise(resolve => setTimeout(resolve, 500));
+        overallProgress = 100;
+        logger.log('Project created successfully');
+        handler?.ui.showLoadingOverlay('Creating project 100%\n✅ Project created successfully!');
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        return {
+            success: true,
+            message: `Project created successfully at ${projectPath} using ${templateId} template`,
+            path: projectFileFullPath
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            message: `Failed to create project: ${error}`,
+            path: projectPath,
+            error: error,
+        };
+    }
+}

package/dist/src/core/types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/dependencies.js

@@ -0,0 +1,82 @@
+/**
+ * Auto-generated file containing all package dependencies and their exact installed versions.
+ * This file is generated by the post-install script.
+ * Do not edit manually - it will be overwritten on next install.
+ *
+ * Versions are extracted from pnpm-lock.yaml to show exact installed versions,
+ * not the version ranges from package.json.
+ *
+ * Includes dependencies from the main package.
+ */
+export const DEPENDENCIES = {
+    '@electron/rebuild': '4.0.1',
+    '@emotion/react': '11.14.0',
+    '@emotion/styled': '11.14.1',
+    '@mui/icons-material': '7.3.5',
+    '@mui/lab': '7.0.0',
+    '@mui/material': '7.3.5',
+    'chokidar': '4.0.3',
+    'commander': '14.0.2',
+    'core-util-is': '1.0.3',
+    'cors': '2.8.5',
+    'electron-devtools-installer': '4.0.0',
+    'electron-is-dev': '3.0.1',
+    'electron-log': '5.4.3',
+    'electron-store': '11.0.2',
+    'electron-updater': '6.6.2',
+    'esbuild': '0.25.12',
+    'express': '5.1.0',
+    'fix-path': '4.0.0',
+    'genesys.js': '3.1.24',
+    'jsdom': '27.2.0',
+    'minimatch': '10.1.1',
+    'multer': '2.0.2',
+    'node-abi': '4.24.0',
+    'react': '19.2.0',
+    'react-dom': '19.2.0',
+    'three': '0.177.0',
+    'upath': '2.0.1',
+    'ws': '8.18.3',
+    'zod': '3.25.76',
+};
+export const DEV_DEPENDENCIES = {
+    '@electron/notarize': '3.1.1',
+    '@modelcontextprotocol/sdk': '1.22.0',
+    '@types/cors': '2.8.19',
+    '@types/electron-store': '1.3.1',
+    '@types/express': '5.0.5',
+    '@types/jsdom': '27.0.0',
+    '@types/minimatch': '5.1.2',
+    '@types/multer': '1.4.13',
+    '@types/react': '19.2.7',
+    '@types/react-dom': '19.2.3',
+    '@types/three': '0.177.0',
+    '@types/ws': '8.18.1',
+    '@typescript-eslint/eslint-plugin': '8.48.0',
+    '@typescript-eslint/parser': '8.48.0',
+    '@vitejs/plugin-react': '4.7.0',
+    'ajv': '8.17.1',
+    'concurrently': '9.2.1',
+    'dotenv-cli': '8.0.0',
+    'electron': '39.2.3',
+    'electron-builder': '26.0.12',
+    'eslint': '9.39.1',
+    'eslint-plugin-import': '2.32.0',
+    'get-port': '7.1.0',
+    'nanoid': '5.1.6',
+    'nodemon': '3.1.11',
+    'ts-morph': '27.0.2',
+    'tsc-watch': '7.2.0',
+    'tsx': '4.20.6',
+    'typescript': '5.9.3',
+    'vite': '6.4.1',
+    'vite-plugin-mkcert': '1.17.9',
+    'vite-plugin-node-polyfills': '0.24.0',
+    'wait-on': '8.0.5',
+    'yaml': '2.8.1',
+    'zod-to-json-schema': '3.25.0',
+};
+export const ALL_DEPENDENCIES = {
+    ...DEPENDENCIES,
+    ...DEV_DEPENDENCIES,
+};

package/dist/src/electron/IpcSerializableError.js

@@ -0,0 +1,38 @@
+// IpcSerializableError.ts
+export class IpcSerializableError extends Error {
+    code;
+    data;
+    // Optionally include additional fields as needed
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = this.constructor.name;
+        // Maintains proper stack trace in V8
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+    // Serialize for IPC
+    static serialize(err) {
+        const plain = {
+            __ipcError: true,
+            name: err.name,
+            message: err.message,
+            stack: err.stack,
+            // If extra fields exist, include them (optional)
+            ...err.code && { code: err.code },
+            ...err.data && { data: err.data },
+        };
+        return plain;
+    }
+    // Deserialize in renderer
+    static deserialize(obj) {
+        if (!obj || !obj.__ipcError)
+            return obj;
+        const error = new IpcSerializableError(obj.message, obj.code, obj.data);
+        error.name = obj.name;
+        error.stack = obj.stack;
+        return error;
+    }
+}

package/dist/src/electron/api.js

@@ -0,0 +1,7 @@
+export var AppStateKey;
+(function (AppStateKey) {
+    AppStateKey["ProjectPath"] = "project.lastOpenedDirectory";
+    AppStateKey["ProjectParentPath"] = "project.lastParentDirectory";
+    AppStateKey["Projects"] = "projects";
+    AppStateKey["WindowState"] = "window.state";
+})(AppStateKey || (AppStateKey = {}));

package/dist/src/electron/backend/actions.js

@@ -0,0 +1,56 @@
+import { dialog } from 'electron';
+import { AppStateKey } from '../api.js';
+import { handlers } from './handler.js';
+import { appState } from './state.js';
+export async function showInExplorer() {
+    const lastOpenedDirectory = appState.getState(AppStateKey.ProjectPath);
+    if (lastOpenedDirectory) {
+        handlers.os.openPath(lastOpenedDirectory);
+    }
+}
+export async function buildProject(runTsc) {
+    try {
+        handlers.ui.showLoadingOverlay('Building Project...');
+        const lastOpenedDirectory = appState.getState(AppStateKey.ProjectPath);
+        if (lastOpenedDirectory) {
+            const result = await handlers.tools.buildProject(lastOpenedDirectory, runTsc);
+            if (!result.success) {
+                handlers.notifications.sendNotification('error', 'Build Project', result.message);
+            }
+        }
+    }
+    finally {
+        handlers.ui.hideLoadingOverlay();
+    }
+}
+export async function checkUpdates() {
+    await handlers.app.checkForUpdates(true);
+}
+export async function openAppLog() {
+    const appInfo = await handlers.app.getInfo();
+    await handlers.os.openPath(appInfo.logPath);
+}
+export async function deleteProject() {
+    const lastOpenedDirectory = appState.getState(AppStateKey.ProjectPath);
+    if (lastOpenedDirectory) {
+        const result = await handlers.tools.deleteProject(lastOpenedDirectory);
+        if (result.success) {
+            handlers.notifications.sendNotification('info', 'Delete Project', result.message);
+        }
+        else {
+            handlers.notifications.sendNotification('error', 'Delete Project', result.message);
+            appState.setState(AppStateKey.ProjectPath, undefined);
+        }
+    }
+}
+export async function showAbout(mainWindow) {
+    const appInfo = await handlers.app.getInfo();
+    let message = `App Version: ${appInfo.appVersion}\n`;
+    message += `Engine Version: ${appInfo.engineVersion}\n`;
+    dialog.showMessageBox(mainWindow, {
+        type: 'info',
+        buttons: ['OK'],
+        title: 'About',
+        message,
+    });
+}