@gnsx/genesys.sdk 4.2.9

package/README.md

@@ -0,0 +1,60 @@
+[![CI](https://github.com/directivegames/genesys.sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/directivegames/genesys.sdk/actions/workflows/ci.yml)
+[![Publish](https://github.com/directivegames/genesys.sdk/actions/workflows/publish.yml/badge.svg)](https://github.com/directivegames/genesys.sdk/actions/workflows/publish.yml)
+
+![Version](https://gist.githubusercontent.com/haowang1013/d024d16ac57a7bfd7038ae32bf239d07/raw/genesys.sdk.svg)
+
+# User Workflow
+- Download and install the latest version from the [Release](https://github.com/directivegames/genesys.sdk/releases) page.
+- Create an empty folder on your disk to store the project.
+- Open the empty folder created earlier in this app, select a template and create a project, then start the file server.
+- Launch the web editor and cursor to develop.
+
+# Developer
+
+## Run Locally
+- `pnpm install`
+- `pnpm dev`: to run the dev version, connects to localhost:3000 if available
+  - run `pnpm dev` on [genesys.ai](https://github.com/directivegames/genesys.ai) to start localhost:3000
+  - if localhost:3000 is started after the sdk, refresh the sdk with Ctrl+R/Ctrl+Shift+R
+- `pnpm dev:watch`: same as `pnpm dev` but with auto-restart on file changes using nodemon
+- `pnpm dev:hosted`: connects to the hosted genesys.ai site.
+- `pnpm dist`: to build the app locally. Installer will be generated in the `dist` folder that you can use to install the app directly on your machine.
+
+## CLI Tools
+The SDK includes command-line tools for creating and building projects without launching the GUI.
+
+### Available Commands
+```bash
+# Show help and available commands
+genesys-sdk --help
+
+# Show version
+genesys-sdk --version
+
+# Create a new project
+genesys-sdk new -n <project-name> -t <template-id> [-p <parent-path>]
+
+# Build an existing project (with TypeScript type checking)
+genesys-sdk build [-p <project-path>]
+
+# Build without type checking (faster)
+genesys-sdk build [-p <project-path>] --no-tsc
+
+# List available project templates
+genesys-sdk list-templates
+```
+
+## New Project Template
+- The logic to setup a new project is in [new-project.ts](src/backend/tools//new-project.ts), it contains a few steps:  
+  - Generate `game.ts` and `default.genesys-scene` based on the selected template.
+  - Generate `package.json` and `{project}.code-workspace` from code.
+  - Copy the files from `assets/new-project` to the project folder.
+  - Run `pnpm install` and `pnpm build` in the project folder.
+
+## Add Electron API
+Electron API is for exposing code that relies on the nodejs environment to the frontend environment.
+
+To add a new one, following this:
+- Define the API in [api.ts](src/api.ts)
+- Add the API wrapper in [preload.ts](src/preload.ts)
+- Implement the API in [handler.ts](src/backend/handler.ts)

package/dist/src/asset-pack/eslint.config.js

@@ -0,0 +1,58 @@
+import tsParser from '@typescript-eslint/parser';
+import noDefaultClassFields from './node_modules/@gnsx/genesys.js/eslint-rules/no-default-class-fields.js';
+import defaultGetterReturnType from './node_modules/@gnsx/genesys.js/eslint-rules/default-getter-return-type.js';
+import noOverrideMethods from './node_modules/@gnsx/genesys.js/eslint-rules/no-override-methods.js';
+import noAsyncOverrideMismatch from './node_modules/@gnsx/genesys.js/eslint-rules/no-async-override-mismatch.js';
+import noDeprecatedConstructor from './node_modules/@gnsx/genesys.js/eslint-rules/no-deprecated-constructor.js';
+import sceneComponentMaterialType from './node_modules/@gnsx/genesys.js/eslint-rules/scene-component-material-type.js';
+import propertyMetadataType from './node_modules/@gnsx/genesys.js/eslint-rules/property-metadata-type.js';
+import tweenTimeArgument from './node_modules/@gnsx/genesys.js/eslint-rules/tween-time-argument.js';
+import requireCreateMethod from './node_modules/@gnsx/genesys.js/eslint-rules/require-create-method.js';
+export default [
+    {
+        ignores: ['dist/**', '.engine/**', 'node_modules/**']
+    },
+    {
+        files: ['**/*.ts', '**/*.tsx'],
+        languageOptions: {
+            parser: tsParser,
+            parserOptions: {
+                project: ['./tsconfig.json']
+            }
+        },
+        plugins: {
+            'custom': {
+                rules: {
+                    'no-override-methods': noOverrideMethods,
+                    'no-default-class-fields': noDefaultClassFields,
+                    'default-getter-return-type': defaultGetterReturnType,
+                    'no-async-override-mismatch': noAsyncOverrideMismatch,
+                    'no-deprecated-constructor': noDeprecatedConstructor,
+                    'scene-component-material-type': sceneComponentMaterialType,
+                    'property-metadata-type': propertyMetadataType,
+                    'tween-time-argument': tweenTimeArgument,
+                    'require-create-method': requireCreateMethod
+                }
+            }
+        },
+        rules: {
+            'custom/no-override-methods': 'error',
+            'custom/no-default-class-fields': 'error',
+            'custom/default-getter-return-type': 'error',
+            'custom/no-async-override-mismatch': 'error',
+            'custom/no-deprecated-constructor': 'error',
+            'custom/scene-component-material-type': 'error',
+            'custom/property-metadata-type': 'error',
+            'custom/tween-time-argument': 'error',
+            'custom/require-create-method': 'error'
+        }
+    },
+    {
+        files: ['games/**/*.ts', 'games/**/*.tsx'],
+        rules: {
+            'no-restricted-imports': ['error', {
+                    patterns: ['../src/**', '!../src/index.js']
+                }]
+        }
+    }
+];

package/dist/src/asset-pack/scripts/post-install.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+// Get the directory of this script
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Find the parent project root by traversing up from node_modules
+ * For pnpm structure like: /project/node_modules/.pnpm/package@version/node_modules/package
+ * We want to find: /project
+ */
+function findProjectRoot() {
+    // Split the current directory path into parts
+    const parts = __dirname.split(path.sep);
+    // Find the first occurrence of 'node_modules' in the path
+    const nodeModulesIndex = parts.indexOf('node_modules');
+    if (nodeModulesIndex > 0) {
+        // Take everything before 'node_modules' and join it back
+        return parts.slice(0, nodeModulesIndex).join(path.sep);
+    }
+    return null;
+}
+// Only run when installed as a dependency in another project
+// Skip if running in the package's own directory during development
+const isInstalledAsDependency = __dirname.includes('node_modules');
+if (isInstalledAsDependency) {
+    try {
+        // Read package.json to get the package name
+        const packageJsonPath = path.resolve(__dirname, '../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const packageName = packageJson.name;
+        // Source: assets folder in this package
+        const sourceAssetsDir = path.resolve(__dirname, '../assets');
+        // Find the parent project root
+        const parentProjectRoot = findProjectRoot();
+        if (!parentProjectRoot) {
+            console.error('Error: Could not find parent project root');
+            process.exit(1);
+        }
+        // Destination: <parent-project>/packs/<package-name>/assets
+        const targetPackDir = path.join(parentProjectRoot, 'packs', packageName);
+        const targetAssetsDir = path.join(targetPackDir, 'assets');
+        // Check if source assets directory exists
+        if (fs.existsSync(sourceAssetsDir)) {
+            // Delete target directory if it already exists
+            if (fs.existsSync(targetPackDir)) {
+                fs.rmSync(targetPackDir, { recursive: true, force: true });
+            }
+            // Create target directory
+            fs.mkdirSync(targetPackDir, { recursive: true });
+            // Copy entire assets folder
+            fs.cpSync(sourceAssetsDir, targetAssetsDir, { recursive: true });
+            console.log(`✓ Assets from "${packageName}" copied to: ${path.relative(parentProjectRoot, targetPackDir)}`);
+        }
+        else {
+            console.log(`⚠ No assets folder found in "${packageName}"`);
+        }
+    }
+    catch (error) {
+        console.error('Error during postinstall:', error);
+        process.exit(1);
+    }
+}

package/dist/src/asset-pack/src/index.js

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

package/dist/src/core/cli.js

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import path from 'path';
+import { createInterface } from 'readline';
+import { fileURLToPath } from 'url';
+import { Command } from 'commander';
+import { getProjectRoot } from './common.js';
+import { buildProject } from './tools/build-project.js';
+import { newAssetPack } from './tools/new-asset-pack.js';
+import { newProject, TEMPLATES } from './tools/new-project.js';
+// CLI Logger implementation
+class ConsoleLogger {
+    getTimestamp() {
+        return new Date().toLocaleTimeString('en-US', { hour12: false });
+    }
+    log(...params) {
+        console.log(`[${this.getTimestamp()}] [INFO]`, ...params);
+    }
+    warn(...params) {
+        console.warn(`[${this.getTimestamp()}] [WARN]`, ...params);
+    }
+    error(...params) {
+        console.error(`[${this.getTimestamp()}] [ERROR]`, ...params);
+    }
+    verbose(...params) {
+        if (process.env.VERBOSE) {
+            console.log(`[${this.getTimestamp()}] [VERBOSE]`, ...params);
+        }
+    }
+}
+// Module-level logger instance
+const logger = new ConsoleLogger();
+// CLI Handler implementation (stub for UI/OS interactions)
+class ConsoleHandler {
+    ui = {
+        async showLoadingOverlay(message) {
+            if (message) {
+                logger.log(message);
+            }
+        },
+        async showErrorDialog(title, message) {
+            logger.error(`${title}: ${message}`);
+        }
+    };
+    os = {
+        async openPath(path) {
+            logger.log(`Project created at: ${path}`);
+        }
+    };
+    app = {
+        isPackaged: false,
+        resourcesPath: getProjectRoot()
+    };
+}
+function printTemplates() {
+    logger.log('\nAvailable Project Templates:\n');
+    for (const template of TEMPLATES) {
+        logger.log(`  ${template.id.padEnd(15)} - ${template.name}`);
+        logger.log('');
+    }
+}
+// Check if running from an installed package (not local development)
+function isInstalledPackage() {
+    try {
+        const currentFile = fileURLToPath(import.meta.url);
+        return currentFile.includes('node_modules');
+    }
+    catch {
+        return false;
+    }
+}
+// Get package.json
+function getPackageJson() {
+    const packageJsonPath = path.join(getProjectRoot(), 'package.json');
+    const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+    return packageJson;
+}
+// Check for updates and prompt user
+async function checkForUpdates() {
+    try {
+        // Only check for updates if running from an installed package
+        if (!isInstalledPackage())
+            return;
+        logger.log('Checking for updates...');
+        const packageJson = getPackageJson();
+        const currentVersion = packageJson.version;
+        const packageName = packageJson.name;
+        if (currentVersion === 'unknown')
+            return;
+        // Fetch latest version from npm registry
+        const response = await fetch(`https://registry.npmjs.org/${packageJson.name}/latest`);
+        if (!response.ok)
+            return;
+        const data = await response.json();
+        const latestVersion = data.version;
+        if (!latestVersion || latestVersion === currentVersion)
+            return;
+        // Compare versions (simple comparison - assumes semantic versioning)
+        if (isNewerVersion(latestVersion, currentVersion)) {
+            logger.log('\n' + '='.repeat(60));
+            logger.log(`🔔 Update Available: ${currentVersion} -> ${latestVersion}`);
+            logger.log('='.repeat(60));
+            // Prompt user if they want to upgrade now
+            const answer = await promptUser('Would you like to upgrade now? (Y/n): ');
+            if (answer === '' || answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes') {
+                logger.log(`\nUpgrading ${packageName}...\n`);
+                const { execSync } = await import('child_process');
+                try {
+                    execSync(`pnpm remove -g ${packageName} && pnpm add -g ${packageName}`, {
+                        stdio: 'inherit'
+                    });
+                    logger.log('\n✅ Upgrade complete! Please run your command again.');
+                    process.exit(0);
+                }
+                catch (error) {
+                    logger.error('\n❌ Upgrade failed. Please run the commands manually.');
+                    logger.log(`  pnpm remove -g ${packageName}`);
+                    logger.log(`  pnpm add -g ${packageName}\n`);
+                }
+            }
+        }
+    }
+    catch {
+        // Silently fail - don't interrupt user workflow with version check errors
+    }
+}
+// Compare semantic versions
+function isNewerVersion(latest, current) {
+    const latestParts = latest.split('.').map(Number);
+    const currentParts = current.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        const latestPart = latestParts[i] || 0;
+        const currentPart = currentParts[i] || 0;
+        if (latestPart > currentPart)
+            return true;
+        if (latestPart < currentPart)
+            return false;
+    }
+    return false;
+}
+// Prompt user for input
+function promptUser(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function main() {
+    // Check for updates at startup
+    await checkForUpdates();
+    const program = new Command();
+    const handler = new ConsoleHandler();
+    const packageJson = getPackageJson();
+    const currentVersion = packageJson.version;
+    program
+        .name('genesys-sdk')
+        .description('Genesys SDK CLI - Game Project Management Tool')
+        .version(currentVersion)
+        .option('--verbose', 'Enable verbose logging');
+    // New project command
+    program
+        .command('new')
+        .description('Create a new game project')
+        .option('-p, --parent-path <path>', 'Parent directory where the project will be created (defaults to current directory)')
+        .requiredOption('-n, --name <name>', 'Name of the new project')
+        .requiredOption('-t, --template <id>', 'Template ID (use list-templates to see available templates)')
+        .action(async (options) => {
+        try {
+            // Validate template ID
+            const template = TEMPLATES.find(t => t.id === options.template);
+            if (!template) {
+                logger.error(`Error: Invalid template ID "${options.template}"\n`);
+                printTemplates();
+                process.exit(1);
+            }
+            const absoluteParentPath = path.resolve(options.parentPath ?? process.cwd());
+            logger.log(`Creating new project "${options.name}" with template "${options.template}"...`);
+            logger.log(`Parent directory: ${absoluteParentPath}\n`);
+            const result = await newProject(absoluteParentPath, options.name, options.template, logger, handler);
+            if (result.success) {
+                logger.log(`\n✅ ${result.message}`);
+                process.exit(0);
+            }
+            else {
+                logger.error(`\n❌ ${result.message}`);
+                if (result.error) {
+                    logger.error(result.error);
+                }
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            logger.error('\n❌ An unexpected error occurred:');
+            logger.error(error);
+            process.exit(1);
+        }
+    });
+    // Build project command
+    program
+        .command('build')
+        .description('Build an existing game project')
+        .option('-p, --path <path>', 'Path to the project to build (defaults to current directory)')
+        .option('--no-tsc', 'Skip TypeScript type checking (faster builds)')
+        .action(async (options) => {
+        try {
+            const absoluteProjectPath = path.resolve(options.path ?? process.cwd());
+            const runTsc = options.tsc;
+            logger.log(`Building project at: ${absoluteProjectPath}`);
+            if (!runTsc) {
+                logger.log('(Skipping TypeScript type checking)');
+            }
+            logger.log('');
+            const result = await buildProject(absoluteProjectPath, runTsc, logger, handler);
+            if (result.success) {
+                logger.log(`\n✅ ${result.message}`);
+                process.exit(0);
+            }
+            else {
+                logger.error(`\n❌ ${result.message}`);
+                if (result.error) {
+                    logger.error(result.error);
+                }
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            logger.error('\n❌ An unexpected error occurred:');
+            logger.error(error);
+            process.exit(1);
+        }
+    });
+    // New asset pack command
+    program
+        .command('new-asset-pack')
+        .description('Create a new asset pack')
+        .option('-p, --parent-path <path>', 'Parent directory where the asset pack will be created (defaults to current directory)')
+        .requiredOption('-n, --name <name>', 'Name of the new asset pack')
+        .action(async (options) => {
+        try {
+            const absoluteParentPath = path.resolve(options.parentPath ?? process.cwd());
+            logger.log(`Creating new asset pack "${options.name}"...`);
+            logger.log(`Parent directory: ${absoluteParentPath}\n`);
+            const result = await newAssetPack(absoluteParentPath, options.name, logger, handler);
+            if (result.success) {
+                logger.log(`\n✅ ${result.message}`);
+                process.exit(0);
+            }
+            else {
+                logger.error(`\n❌ ${result.message}`);
+                if (result.error) {
+                    logger.error(result.error);
+                }
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            logger.error('\n❌ An unexpected error occurred:');
+            logger.error(error);
+            process.exit(1);
+        }
+    });
+    // List templates command
+    program
+        .command('list-templates')
+        .description('List available project templates')
+        .action(() => {
+        printTemplates();
+    });
+    // Add examples to help
+    program.addHelpText('after', `
+Examples:
+  # Create a new FPS game project in current directory
+  $ genesys-sdk new -n my-fps-game -t fps
+
+  # Create a new FPS game project in a specific directory
+  $ genesys-sdk new -p ./projects -n my-fps-game -t fps
+
+  # Build current directory project with type checking
+  $ genesys-sdk build
+
+  # Build a specific project with type checking
+  $ genesys-sdk build -p ./projects/my-game
+
+  # Create a new asset pack in current directory
+  $ genesys-sdk new-asset-pack -n my-asset-pack
+
+  # Create a new asset pack in a specific directory
+  $ genesys-sdk new-asset-pack -p ./packs -n my-asset-pack
+  
+  # List all available templates
+  $ genesys-sdk list-templates
+`);
+    // Parse arguments
+    await program.parseAsync(process.argv);
+}
+// Run the CLI
+main();