@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,201 @@
+import Store from 'electron-store';
+import upath from 'upath';
+import { AppStateKey } from '../api.js';
+// Default state values
+const defaultState = {
+    project: {
+        lastOpenedDirectory: undefined,
+        lastParentDirectory: undefined,
+    },
+    projects: {},
+    window: {
+        state: undefined,
+    },
+};
+// Create the store instance with proper typing
+const store = new Store({
+    defaults: defaultState,
+    name: 'genesys-config',
+});
+// State management class
+export class AppStateManager {
+    static instance;
+    store;
+    callbacks = new Set();
+    constructor() {
+        this.store = store;
+    }
+    static getInstance() {
+        if (!AppStateManager.instance) {
+            AppStateManager.instance = new AppStateManager();
+        }
+        return AppStateManager.instance;
+    }
+    getState(key) {
+        return this.store.get(key);
+    }
+    setState(key, value) {
+        const oldValue = this.store.get(key);
+        if (value === undefined || value === null) {
+            this.store.delete(key);
+        }
+        else {
+            this.store.set(key, value);
+        }
+        // Notify all callbacks about the state change
+        this.callbacks.forEach(callback => {
+            try {
+                callback(key, oldValue, value);
+            }
+            catch (error) {
+                console.error('Error in state change callback:', error);
+            }
+        });
+    }
+    /**
+     * Register a callback to be called when state changes
+     * @param callback Function to call when state changes
+     * @returns Function to unregister the callback
+     */
+    onStateChange(callback) {
+        this.callbacks.add(callback);
+        // Return unsubscribe function
+        return () => {
+            this.callbacks.delete(callback);
+        };
+    }
+    /**
+     * Remove all state change callbacks
+     */
+    clearCallbacks() {
+        this.callbacks.clear();
+    }
+    /**
+     * Normalize a project path for consistent storage and comparison
+     * Handles both path separators and case sensitivity on Windows
+     * @param projectPath The path to normalize
+     * @returns Normalized path
+     */
+    normalizeProjectPath(projectPath) {
+        // First normalize path separators
+        let normalized = upath.normalize(projectPath);
+        // On Windows, paths are case-insensitive, so normalize to lowercase for comparison
+        // but preserve the original casing for display by using a consistent casing strategy
+        if (process.platform === 'win32') {
+            // Convert to lowercase for consistent comparison, but keep original structure
+            normalized = normalized.toLowerCase();
+        }
+        return normalized;
+    }
+    /**
+   * Update the last opened time for a project
+   * @param projectPath The path to the project
+   * @param timestamp Optional timestamp, defaults to current time
+   */
+    updateProjectLastOpened(projectPath, timestamp = Date.now()) {
+        // Normalize and handle case-insensitive duplicates on Windows
+        const normalizedPath = this.normalizeProjectPath(projectPath);
+        const currentProjects = this.getState(AppStateKey.Projects) ?? {};
+        // Clean up and normalize all existing project paths
+        const cleanedProjects = {};
+        const pathMap = new Map();
+        // Process existing projects: normalize all paths and keep latest timestamp for duplicates
+        for (const [path, existingTimestamp] of Object.entries(currentProjects)) {
+            const normalizedExistingPath = this.normalizeProjectPath(path);
+            const timestampValue = existingTimestamp;
+            const existingMappedTimestamp = pathMap.get(normalizedExistingPath);
+            // Keep the latest timestamp if we find duplicates
+            if (!existingMappedTimestamp || timestampValue > existingMappedTimestamp) {
+                pathMap.set(normalizedExistingPath, timestampValue);
+            }
+        }
+        // Add/update the current project
+        pathMap.set(normalizedPath, timestamp);
+        // Build final cleaned projects object with normalized paths
+        for (const [path, ts] of pathMap) {
+            cleanedProjects[path] = ts;
+        }
+        console.log(`[state] 📁 Updated project tracking for: ${normalizedPath}`);
+        // Log cleanup if paths were normalized or duplicates removed
+        const originalCount = Object.keys(currentProjects).length;
+        const cleanedCount = Object.keys(cleanedProjects).length;
+        if (originalCount !== cleanedCount) {
+            console.log(`[state] 🧹 Normalized paths and cleaned up ${originalCount - cleanedCount} duplicate entries`);
+        }
+        else {
+            // Check if any paths were actually normalized
+            const pathsNormalized = Object.keys(currentProjects).some(path => path !== this.normalizeProjectPath(path));
+            if (pathsNormalized) {
+                console.log('[state] 🧹 Normalized project paths for consistency');
+            }
+        }
+        this.setState(AppStateKey.Projects, cleanedProjects);
+    }
+    /**
+     * Get the last opened time for a project
+     * @param projectPath The path to the project
+     * @returns The timestamp or undefined if not found
+     */
+    getProjectLastOpened(projectPath) {
+        const normalizedPath = this.normalizeProjectPath(projectPath);
+        const projects = this.getState(AppStateKey.Projects) ?? {};
+        return projects[normalizedPath];
+    }
+    /**
+   * Get all projects data (path -> timestamp mapping)
+   */
+    getAllProjects() {
+        return this.getState(AppStateKey.Projects) ?? {};
+    }
+    /**
+     * Clean up duplicate projects in the existing state
+     * This can be called to fix any existing duplicates
+     */
+    cleanupDuplicateProjects() {
+        const currentProjects = this.getState(AppStateKey.Projects) ?? {};
+        const pathMap = new Map();
+        // Process existing projects: normalize all paths and keep latest timestamp for duplicates
+        for (const [path, timestamp] of Object.entries(currentProjects)) {
+            const normalizedPath = this.normalizeProjectPath(path);
+            const timestampValue = timestamp;
+            const existingTimestamp = pathMap.get(normalizedPath);
+            // Keep the latest timestamp if we find duplicates
+            if (!existingTimestamp || timestampValue > existingTimestamp) {
+                pathMap.set(normalizedPath, timestampValue);
+            }
+        }
+        // Build cleaned projects object
+        const cleanedProjects = {};
+        for (const [path, ts] of pathMap) {
+            cleanedProjects[path] = ts;
+        }
+        const originalCount = Object.keys(currentProjects).length;
+        const cleanedCount = Object.keys(cleanedProjects).length;
+        if (originalCount !== cleanedCount) {
+            console.log(`[state] 🧹 Cleaned up ${originalCount - cleanedCount} duplicate project entries`);
+            this.setState(AppStateKey.Projects, cleanedProjects);
+        }
+        else {
+            console.log('[state] ✅ No duplicate projects found');
+        }
+    }
+    /**
+   * Remove a project from the projects list
+   * @param projectPath The path to the project to remove
+   */
+    removeProject(projectPath) {
+        const normalizedPath = this.normalizeProjectPath(projectPath);
+        const currentProjects = this.getState(AppStateKey.Projects) ?? {};
+        // Remove both the normalized path and any potential duplicates
+        const cleanedProjects = {};
+        for (const [path, timestamp] of Object.entries(currentProjects)) {
+            if (this.normalizeProjectPath(path) !== normalizedPath) {
+                cleanedProjects[this.normalizeProjectPath(path)] = timestamp;
+            }
+        }
+        console.log(`[state] 🗑️ Removed project: ${normalizedPath}`);
+        this.setState(AppStateKey.Projects, cleanedProjects);
+    }
+}
+// Export singleton instance
+export const appState = AppStateManager.getInstance();

package/dist/src/electron/backend/tools/const.js

@@ -0,0 +1,9 @@
+import path from 'path';
+import isDev from 'electron-is-dev';
+import * as ENGINE from 'genesys.js';
+// MUST be kept in sync with https://github.com/directivegames/genesys.ai/blob/develop/src/const.ts
+export const GENESYS_URL = 'https://web--genesys-ai.us-central1.hosted.app/dashboard';
+export const GENESYS_LOCAL_URL = 'http://localhost:3000/dashboard';
+export const DefaultGameFilePath = path.join('src', ENGINE.DEFAULT_GAME_NAME);
+export const ReleaseUrl = 'https://github.com/directivegames/genesys.sdk-release/releases';
+export const DefaultFileServerPort = !isDev ? 4000 : 4001;

package/dist/src/electron/backend/tools/file-server.js

@@ -0,0 +1,383 @@
+import fs from 'fs';
+import path from 'path';
+import chokidar from 'chokidar';
+import cors from 'cors';
+import { dialog, app as electronApp } from 'electron';
+import express from 'express';
+import { minimatch } from 'minimatch';
+import multer from 'multer';
+import { WebSocketServer } from 'ws';
+import { runCommand } from '../../../core/common.js';
+import { IgnoredFiles } from '../../../core/index.js';
+import { buildProject } from '../../../core/tools/build-project.js';
+import { getAppInfo } from '../handler.js';
+import { logger } from '../logging.js';
+import { DefaultFileServerPort } from './const.js';
+const hiddenFiles = [
+    ...IgnoredFiles,
+    '.cursor',
+    '.engine',
+    '.idea',
+    '.dist',
+    'dist',
+    '.editor',
+    'node_modules',
+    'scripts',
+    '.gitignore',
+    '.git',
+    'package.json',
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'tsconfig.json',
+    '*.code-workspace',
+    '.placeholder',
+];
+/**
+ * Check if a filename matches any of the hidden file patterns
+ */
+function isHiddenFile(filename) {
+    return hiddenFiles.some(pattern => {
+        // If pattern contains wildcards, use minimatch for glob matching
+        if (pattern.includes('*') || pattern.includes('?') || pattern.includes('[')) {
+            return minimatch(filename, pattern);
+        }
+        // Otherwise, use exact string matching
+        return filename === pattern;
+    });
+}
+/**
+ * Check if a file path should be ignored by the watcher
+ * This handles both files and directories
+ */
+function shouldIgnorePath(filePath, rootDir) {
+    const relativePath = path.relative(rootDir, filePath);
+    const pathParts = relativePath.split(path.sep);
+    // Check if any part of the path matches hidden patterns
+    return pathParts.some(part => isHiddenFile(part)) ||
+        isHiddenFile(path.basename(filePath));
+}
+class FileServer {
+    server = null;
+    wsServer = null;
+    port = DefaultFileServerPort;
+    isRunning = false;
+    connections = new Set(); // Track all open connections
+    constructor() { }
+    createApp(rootDir) {
+        const app = express();
+        app.use(cors());
+        app.use(express.json());
+        app.use(express.static(rootDir, {
+            dotfiles: 'allow'
+        }));
+        const storage = multer.diskStorage({
+            destination: (req, file, cb) => {
+                const uploadPath = req.headers['x-upload-path'] || '';
+                const absPath = path.join(rootDir, uploadPath);
+                if (!fs.existsSync(absPath)) {
+                    fs.mkdirSync(absPath, { recursive: true });
+                }
+                cb(null, absPath);
+            },
+            filename: (req, file, cb) => {
+                cb(null, file.originalname);
+            }
+        });
+        const upload = multer({ storage });
+        app.get('', (req, res) => {
+            res.json(getAppInfo());
+        });
+        app.get('/api/files', (req, res) => {
+            const absPath = path.join(rootDir, req.query.path || '');
+            const recursive = req.query.recursive === 'true';
+            const directories = [];
+            const files = [];
+            if (fs.existsSync(absPath)) {
+                if (recursive) {
+                    const walkDir = (currentPath, relativePath = '') => {
+                        const items = fs.readdirSync(currentPath).filter(file => !isHiddenFile(file));
+                        items.forEach(item => {
+                            const itemPath = path.join(currentPath, item);
+                            const itemRelativePath = path.join(relativePath, item);
+                            const stats = fs.statSync(itemPath);
+                            const normalizedPath = itemRelativePath.replace(/\\/g, '/');
+                            const itemInfo = {
+                                name: item,
+                                path: normalizedPath,
+                                absolutePath: itemPath,
+                                size: stats.size,
+                                modifiedTime: stats.mtime
+                            };
+                            if (stats.isDirectory()) {
+                                directories.push(itemInfo);
+                                walkDir(itemPath, itemRelativePath);
+                            }
+                            else {
+                                files.push(itemInfo);
+                            }
+                        });
+                    };
+                    walkDir(absPath, path.relative(rootDir, absPath));
+                }
+                else {
+                    const items = fs.readdirSync(absPath).filter(file => !isHiddenFile(file));
+                    items.forEach(item => {
+                        const filePath = path.join(absPath, item);
+                        const stats = fs.statSync(filePath);
+                        const relativePath = path.relative(rootDir, filePath).replace(/\\/g, '/');
+                        const itemInfo = {
+                            name: item,
+                            path: relativePath,
+                            absolutePath: filePath,
+                            size: stats.size,
+                            modifiedTime: stats.mtime
+                        };
+                        if (stats.isDirectory()) {
+                            directories.push(itemInfo);
+                        }
+                        else {
+                            files.push(itemInfo);
+                        }
+                    });
+                }
+            }
+            res.json({
+                directories,
+                files
+            });
+        });
+        app.post('/api/files', (req, res) => {
+            if (!req.body.path) {
+                res.status(400).json({ error: 'File path is required' });
+                return;
+            }
+            const absPath = path.join(rootDir, req.body.path);
+            const dirPath = path.dirname(absPath);
+            if (!fs.existsSync(dirPath)) {
+                fs.mkdirSync(dirPath, { recursive: true });
+            }
+            fs.writeFileSync(absPath, req.body.content ?? '');
+            res.json({ success: true, path: req.body.path });
+            logger.verbose(`File updated: ${absPath}`);
+        });
+        app.post('/api/files/upload', upload.single('file'), (req, res) => {
+            if (!req.file) {
+                res.status(400).json({ error: 'No file uploaded' });
+                return;
+            }
+            const relativePath = path.join(req.headers['x-upload-path'] || '', req.file.originalname)
+                .replace(/\\/g, '/');
+            const absPath = path.join(rootDir, relativePath);
+            res.json({
+                success: true,
+                filename: req.file.originalname,
+                path: relativePath
+            });
+            logger.verbose(`File uploaded: ${absPath}`);
+        });
+        app.post('/api/build-project', async (req, res) => {
+            try {
+                const projectPath = req.body?.projectPath ?? rootDir;
+                const runTsc = req.body?.runTsc ?? false;
+                const handler = {
+                    ui: {
+                        showLoadingOverlay: async () => { },
+                        showErrorDialog: async (title, message) => {
+                            dialog.showErrorBox(title, message);
+                        }
+                    },
+                    os: {
+                        openPath: async () => { }
+                    },
+                    app: {
+                        isPackaged: electronApp.isPackaged,
+                        resourcesPath: process.resourcesPath
+                    }
+                };
+                const result = await buildProject(projectPath, runTsc, logger, handler);
+                if (result.success) {
+                    res.json({
+                        success: result.success,
+                        message: result.message,
+                        error: result.error
+                    });
+                }
+                else {
+                    res.status(500).json({
+                        success: result.success,
+                        message: result.message,
+                        error: result.error
+                    });
+                }
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+            }
+        });
+        app.post('/api/exec', (req, res) => {
+            if (!req.body.command) {
+                res.status(400).json({ error: 'No command provided' });
+                return;
+            }
+            logger.log(`Executing command: ${req.body.command}`);
+            try {
+                runCommand(req.body.command, null, logger);
+            }
+            catch (error) {
+                res.status(500).json({ error: error.message });
+                return;
+            }
+            res.json({
+                success: true,
+                command: req.body.command
+            });
+            logger.log(`Command executed: ${req.body.command}`);
+        });
+        app.delete('/api/files', (req, res) => {
+            if (!req.query.path) {
+                res.status(400).json({ error: 'Path is required' });
+                return;
+            }
+            const absPath = path.join(rootDir, req.query.path);
+            if (!fs.existsSync(absPath)) {
+                res.status(404).json({ error: 'File or directory not found' });
+                return;
+            }
+            const stats = fs.statSync(absPath);
+            if (stats.isDirectory()) {
+                fs.rmdirSync(absPath, { recursive: true });
+            }
+            else {
+                fs.unlinkSync(absPath);
+            }
+            res.json({ success: true, path: req.query.path });
+            logger.log(`File deleted: ${absPath}`);
+        });
+        return app;
+    }
+    createWsServer(rootDir) {
+        if (!this.server) {
+            throw new Error('Server must be initialized before creating WebSocket server');
+        }
+        const wss = new WebSocketServer({ server: this.server });
+        function broadcastChange(type, filePath, action) {
+            const payload = JSON.stringify({
+                type,
+                path: filePath,
+                action
+            });
+            wss.clients.forEach(client => {
+                if (client.readyState === 1) { // 1 = OPEN
+                    client.send(payload);
+                }
+            });
+        }
+        // Watch for file/folder changes using chokidar
+        const watcher = chokidar.watch(rootDir, {
+            persistent: true,
+            ignoreInitial: true,
+            depth: 99,
+            ignored: (filePath) => shouldIgnorePath(filePath, rootDir),
+        });
+        watcher
+            .on('add', filePath => {
+            const rel = path.relative(rootDir, filePath).replace(/\\/g, '/');
+            logger.verbose(`[watcher] add: ${rel}`);
+            broadcastChange('file', rel, 'created');
+        })
+            .on('change', filePath => {
+            const rel = path.relative(rootDir, filePath).replace(/\\/g, '/');
+            logger.verbose(`[watcher] change: ${rel}`);
+            broadcastChange('file', rel, 'modified');
+        })
+            .on('unlink', filePath => {
+            const rel = path.relative(rootDir, filePath).replace(/\\/g, '/');
+            logger.verbose(`[watcher] unlink: ${rel}`);
+            broadcastChange('file', rel, 'deleted');
+        })
+            .on('addDir', dirPath => {
+            const rel = path.relative(rootDir, dirPath).replace(/\\/g, '/');
+            logger.verbose(`[watcher] addDir: ${rel}`);
+            broadcastChange('folder', rel, 'created');
+        })
+            .on('unlinkDir', dirPath => {
+            const rel = path.relative(rootDir, dirPath).replace(/\\/g, '/');
+            logger.verbose(`[watcher] unlinkDir: ${rel}`);
+            broadcastChange('folder', rel, 'deleted');
+        });
+        wss.on('connection', ws => {
+            logger.log('WebSocket client connected');
+            ws.on('close', () => {
+                logger.log('WebSocket client disconnected');
+            });
+        });
+        return wss;
+    }
+    async start(port, rootDir) {
+        if (this.isRunning) {
+            await this.stop();
+        }
+        this.port = port;
+        return new Promise((resolve, reject) => {
+            try {
+                const app = this.createApp(rootDir);
+                this.server = app.listen(this.port, '0.0.0.0', () => {
+                    this.isRunning = true;
+                    logger.log(`File server started on port ${this.port} at ${rootDir}`);
+                    resolve();
+                });
+                // Track all open TCP connections!
+                this.server.on('connection', (conn) => {
+                    this.connections.add(conn);
+                    conn.on('close', () => this.connections.delete(conn));
+                });
+                this.server.on('error', (err) => {
+                    this.isRunning = false;
+                    reject(err);
+                });
+                this.wsServer = this.createWsServer(rootDir);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    async stop() {
+        if (!this.isRunning || !this.server) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            try {
+                logger.log('Stopping file server...');
+                // Close WebSocket server if it exists
+                if (this.wsServer) {
+                    this.wsServer.close();
+                    this.wsServer = null;
+                    logger.log('WebSocket server stopped');
+                }
+                this.server.close(() => {
+                    this.isRunning = false;
+                    this.server = null;
+                    logger.log('File server stopped');
+                    resolve();
+                });
+                logger.log(`Destroying ${this.connections.size} connections.`);
+                for (const conn of this.connections) {
+                    conn.destroy();
+                }
+                this.connections.clear();
+            }
+            catch (error) {
+                logger.error('Failed to stop file server:', error);
+                reject(error);
+            }
+        });
+    }
+    isServerRunning() {
+        return this.isRunning;
+    }
+    getPort() {
+        return this.port;
+    }
+}
+export const fileServer = new FileServer();