@directivegames/genesys.sdk 3.2.2

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

@@ -0,0 +1,441 @@
+import fs from 'fs';
+import pathlib from 'path';
+import path from 'path';
+import { dialog, ipcMain, shell } from 'electron';
+import { app } from 'electron';
+import isDev from 'electron-is-dev';
+import electronUpdater from 'electron-updater';
+import upath from 'upath';
+import { getAppVersion, getEngineVersion, getProjectFolderAndFile, IgnoredFiles, newProject, TEMPLATES } from '../../core/index.js';
+import { buildProject } from '../../core/tools/build-project.js';
+import { IpcSerializableError } from '../IpcSerializableError.js';
+import { getLogPath, logger } from './logging.js';
+import { clearPendingDeepLinkUrl, getPendingDeepLinkUrl, mainWindow } from './main.js';
+import { appState } from './state.js';
+import { ReleaseUrl } from './tools/const.js';
+import { fileServer } from './tools/file-server.js';
+import { openProject } from './tools/open-project.js';
+const { autoUpdater } = electronUpdater;
+export const handlers = {
+    fileServer: {
+        start: async (port, rootDir) => {
+            try {
+                await fileServer.start(port, fs.lstatSync(rootDir).isDirectory() ? rootDir : pathlib.dirname(rootDir));
+                return null;
+            }
+            catch (error) {
+                return IpcSerializableError.serialize(error);
+            }
+        },
+        stop: async () => {
+            try {
+                await fileServer.stop();
+                return null;
+            }
+            catch (error) {
+                return IpcSerializableError.serialize(error);
+            }
+        },
+        status: async () => {
+            return {
+                isRunning: fileServer.isServerRunning(),
+                port: fileServer.getPort(),
+            };
+        },
+    },
+    os: {
+        chooseDirectory: async (title) => {
+            const { canceled, filePaths } = await dialog.showOpenDialog({
+                title,
+                properties: ['openDirectory'],
+            });
+            return canceled ? null : upath.normalize(filePaths[0]);
+        },
+        chooseGenesysProject: async (title) => {
+            const { canceled, filePaths } = await dialog.showOpenDialog({
+                title,
+                properties: ['openFile'],
+                filters: [
+                    { name: 'Genesys Project', extensions: ['genesys-project'] }
+                ]
+            });
+            return canceled ? null : upath.normalize(filePaths[0]);
+        },
+        openPath: async (path) => {
+            const { folder } = getProjectFolderAndFile(path, logger);
+            await shell.openPath(folder);
+        },
+        openUrl: async (url) => {
+            await shell.openExternal(url);
+        },
+        showItemInFolder: (path) => {
+            shell.showItemInFolder(path);
+        },
+        readDirectory: async (path) => {
+            if (!fs.existsSync(path)) {
+                return null;
+            }
+            const folder = fs.lstatSync(path).isDirectory() ? path : pathlib.dirname(path);
+            return fs.readdirSync(folder).filter(file => !IgnoredFiles.includes(file));
+        },
+        exists: async (path) => {
+            return fs.existsSync(path);
+        },
+    },
+    tools: {
+        // given a folder or a file path, return the folder and the project file name
+        // if it's a directory, will try find the project file in that directory
+        // if folder is invalid or no project file is found, return empty strings
+        getProjectFolderAndFile: async (path) => {
+            return getProjectFolderAndFile(path, logger);
+        },
+        createProject: async (parentPath, projectName, templateId) => {
+            handlers.ui.showLoadingOverlay('Creating Project...');
+            const res = await newProject(parentPath, projectName, templateId, logger, handlerForCore);
+            if (res.error instanceof Error) {
+                res.error = IpcSerializableError.serialize(res.error);
+            }
+            // Track project creation time if successful
+            if (res.success && res.path) {
+                console.log(`[projects] 📝 Tracking new project: ${res.path}`);
+                appState.updateProjectLastOpened(res.path);
+            }
+            handlers.ui.hideLoadingOverlay();
+            return res;
+        },
+        openProject: async (projectPath) => {
+            const res = await openProject(projectPath, () => handlers.ui.showLoadingOverlay('Opening Project...'), () => handlers.ui.hideLoadingOverlay(), () => handlers.ui.showLoadingOverlay('Verifying Project...'), () => handlers.ui.hideLoadingOverlay(), () => handlers.ui.showLoadingOverlay('Updating Project...'), () => handlers.ui.hideLoadingOverlay());
+            if (res.error instanceof Error) {
+                res.error = IpcSerializableError.serialize(res.error);
+            }
+            // Track project open time if successful
+            if (res.success && res.path) {
+                console.log(`[projects] 📂 Tracking opened project: ${res.path}`);
+                appState.updateProjectLastOpened(res.path);
+            }
+            return res;
+        },
+        deleteProject: async (projectPath) => {
+            if (!fs.existsSync(projectPath)) {
+                return {
+                    success: false,
+                    message: 'Project not found',
+                    path: projectPath
+                };
+            }
+            handlers.ui.showLoadingOverlay('Deleting Project...');
+            try {
+                const { folder: projectFolder } = getProjectFolderAndFile(projectPath, logger);
+                const entries = fs.readdirSync(projectFolder, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = pathlib.join(projectFolder, entry.name);
+                    fs.rmSync(fullPath, { recursive: true, force: true });
+                }
+                // Remove the project from the projects list
+                appState.removeProject(projectPath);
+                return {
+                    success: true,
+                    message: `Project ${projectPath} deleted`,
+                    path: projectPath
+                };
+            }
+            catch (error) {
+                return {
+                    success: false,
+                    message: 'Failed to delete project',
+                    path: projectPath,
+                    error: IpcSerializableError.serialize(error),
+                };
+            }
+            finally {
+                handlers.ui.hideLoadingOverlay();
+            }
+        },
+        buildProject: async (projectPath, runTsc) => {
+            handlers.ui.showLoadingOverlay('Building Project...');
+            const res = await buildProject(projectPath, runTsc, logger, handlerForCore);
+            if (res.error instanceof Error) {
+                res.error = IpcSerializableError.serialize(res.error);
+            }
+            handlers.ui.hideLoadingOverlay();
+            return res;
+        },
+        getProjectTemplates: async () => {
+            return TEMPLATES;
+        },
+        getProjects: async () => {
+            const projects = appState.getAllProjects();
+            return Object.entries(projects)
+                .map(([projectFilePath, lastOpened]) => {
+                // Check if the project path exists
+                const pathExists = fs.existsSync(projectFilePath);
+                let projectFileExists = false;
+                let projectFile = '';
+                let projectFolder = '';
+                if (pathExists) {
+                    try {
+                        // Get project folder and file info
+                        const { folder, file } = getProjectFolderAndFile(projectFilePath, logger);
+                        projectFolder = folder;
+                        projectFile = file;
+                        // Check if the project file exists
+                        if (folder && file) {
+                            const projectFilePath = path.join(folder, file);
+                            projectFileExists = fs.existsSync(projectFilePath);
+                        }
+                    }
+                    catch (error) {
+                        // If getProjectFolderAndFile throws an error, consider the project as not found
+                        projectFileExists = false;
+                    }
+                }
+                const isFound = pathExists && projectFileExists;
+                if (!isFound) {
+                    [projectFolder, projectFile] = [path.dirname(projectFilePath), path.basename(projectFilePath)];
+                }
+                return {
+                    folder: projectFolder,
+                    file: projectFile,
+                    lastOpened: lastOpened,
+                    isFound
+                };
+            })
+                .sort((a, b) => b.lastOpened - a.lastOpened);
+        },
+    },
+    app: {
+        getInfo: async () => {
+            return getAppInfo();
+        },
+        checkForUpdates: async (notifyWhenNoUpdates) => {
+            const result = await autoUpdater.checkForUpdates();
+            if (!result || !result.isUpdateAvailable) {
+                if (notifyWhenNoUpdates) {
+                    dialog.showMessageBox(mainWindow, {
+                        type: 'info',
+                        buttons: ['OK'],
+                        title: 'No Updates Available',
+                        message: 'You are running the latest version of the application',
+                    });
+                }
+                return;
+            }
+            else {
+                dialog.showMessageBox(mainWindow, {
+                    type: 'info',
+                    buttons: ['Manual Download', 'OK'],
+                    title: 'Update Available',
+                    message: 'An update is available and is being downloaded. You will be notified when it is ready to install.',
+                }).then(async ({ response }) => {
+                    if (response === 0)
+                        await shell.openExternal(ReleaseUrl);
+                });
+                return;
+            }
+        },
+        getPath: (name) => {
+            return app.getPath(name);
+        },
+        getState: async (key) => {
+            return appState.getState(key);
+        },
+        setState: async (key, value) => {
+            appState.setState(key, value);
+        },
+    },
+    notifications: {
+        sendNotification: async (level, title, message) => {
+            const notification = {
+                level,
+                title,
+                message,
+            };
+            // Send notification to all renderer processes
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.webContents.send('notification', notification);
+            }
+        },
+    },
+    ui: {
+        reload: (force) => {
+            force ? mainWindow?.webContents.reloadIgnoringCache() : mainWindow?.reload();
+        },
+        showLoadingOverlay: async (message) => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.webContents.send('loading-overlay-show', message ?? 'Loading...');
+                mainWindow.setProgressBar(99, { mode: 'indeterminate' });
+            }
+        },
+        hideLoadingOverlay: async () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.webContents.send('loading-overlay-hide');
+                mainWindow.setProgressBar(-1);
+            }
+        },
+        showErrorDialog: async (title, message) => {
+            dialog.showErrorBox(title, message);
+        },
+    },
+    window: {
+        minimize: () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.minimize();
+            }
+        },
+        maximize: () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                if (mainWindow.isMaximized()) {
+                    mainWindow.unmaximize();
+                }
+                else {
+                    mainWindow.maximize();
+                }
+            }
+        },
+        unmaximize: () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.unmaximize();
+            }
+        },
+        isMaximized: async () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                return mainWindow.isMaximized();
+            }
+            return false;
+        },
+        close: () => {
+            if (mainWindow && !mainWindow.isDestroyed()) {
+                mainWindow.close();
+            }
+        },
+    },
+};
+const handlerForCore = {
+    ui: handlers.ui,
+    os: handlers.os,
+    app: {
+        isPackaged: app.isPackaged,
+        resourcesPath: process.resourcesPath,
+    }
+};
+ipcMain.handle('fileServer.start', async (_, port, rootDir) => {
+    return handlers.fileServer.start(port, rootDir);
+});
+ipcMain.handle('fileServer.stop', async () => {
+    return handlers.fileServer.stop();
+});
+ipcMain.handle('fileServer.status', async () => {
+    return handlers.fileServer.status();
+});
+ipcMain.handle('os.chooseDirectory', async (_, title) => {
+    return handlers.os.chooseDirectory(title);
+});
+ipcMain.handle('os.chooseGenesysProject', async (_, title) => {
+    return handlers.os.chooseGenesysProject(title);
+});
+ipcMain.handle('os.openPath', async (_, path) => {
+    return handlers.os.openPath(path);
+});
+ipcMain.handle('os.openUrl', async (_, url) => {
+    return handlers.os.openUrl(url);
+});
+ipcMain.on('os.showItemInFolder', (_, path) => {
+    return handlers.os.showItemInFolder(path);
+});
+ipcMain.handle('os.readDirectory', async (_, path) => {
+    return handlers.os.readDirectory(path);
+});
+ipcMain.handle('os.exists', async (_, path) => {
+    return handlers.os.exists(path);
+});
+ipcMain.handle('os.platform', async () => {
+    return process.platform;
+});
+ipcMain.handle('tools.getProjectFolderAndFile', async (_, path) => {
+    return handlers.tools.getProjectFolderAndFile(path);
+});
+ipcMain.handle('tools.createProject', async (_, parentPath, projectName, templateId) => {
+    return handlers.tools.createProject(parentPath, projectName, templateId);
+});
+ipcMain.handle('tools.openProject', async (_, projectPath) => {
+    return handlers.tools.openProject(projectPath);
+});
+ipcMain.handle('tools.deleteProject', async (_, projectPath) => {
+    return handlers.tools.deleteProject(projectPath);
+});
+ipcMain.handle('tools.buildProject', async (_, projectPath, runTsc) => {
+    return handlers.tools.buildProject(projectPath, runTsc);
+});
+ipcMain.handle('tools.getProjectTemplates', async () => {
+    return handlers.tools.getProjectTemplates();
+});
+ipcMain.handle('tools.getProjects', async () => {
+    return handlers.tools.getProjects();
+});
+ipcMain.on('tools.toggleDevConsole', () => {
+    mainWindow && mainWindow.webContents.toggleDevTools();
+});
+ipcMain.handle('app.getInfo', async () => {
+    return handlers.app.getInfo();
+});
+ipcMain.handle('app.getPath', async (_, name) => {
+    return handlers.app.getPath(name);
+});
+ipcMain.handle('app.checkForUpdates', async (_, notifyWhenNoUpdates) => {
+    return handlers.app.checkForUpdates(notifyWhenNoUpdates);
+});
+ipcMain.handle('app.getState', async (_, key) => {
+    return handlers.app.getState(key);
+});
+ipcMain.handle('app.setState', async (_, key, value) => {
+    return handlers.app.setState(key, value);
+});
+ipcMain.handle('notifications.sendNotification', async (_, level, title, message) => {
+    return handlers.notifications.sendNotification(level, title, message);
+});
+ipcMain.on('ui.reload', (_, force) => {
+    handlers.ui.reload(force);
+});
+ipcMain.handle('ui.showLoadingOverlay', async (_, message) => {
+    return handlers.ui.showLoadingOverlay(message);
+});
+ipcMain.handle('ui.hideLoadingOverlay', async () => {
+    return handlers.ui.hideLoadingOverlay();
+});
+ipcMain.on('dev.loadUrl', (_, url) => {
+    isDev && mainWindow?.loadURL(url);
+});
+ipcMain.on('window.minimize', () => {
+    handlers.window.minimize();
+});
+ipcMain.on('window.maximize', () => {
+    handlers.window.maximize();
+});
+ipcMain.on('window.unmaximize', () => {
+    handlers.window.unmaximize();
+});
+ipcMain.handle('window.isMaximized', async () => {
+    return handlers.window.isMaximized();
+});
+ipcMain.on('window.close', () => {
+    handlers.window.close();
+});
+ipcMain.on('register-deep-link', () => {
+    console.log('🔗 [deep-link] Renderer registered for deep links');
+    // Check if there's a pending deep link URL
+    const pendingUrl = getPendingDeepLinkUrl();
+    if (pendingUrl && mainWindow && !mainWindow.isDestroyed()) {
+        console.log('🔗 [deep-link] Sending pending deep link to renderer:', pendingUrl);
+        mainWindow.webContents.send('deep-link', pendingUrl);
+        clearPendingDeepLinkUrl();
+    }
+});
+export function getAppInfo() {
+    return {
+        isDev: isDev,
+        engineVersion: getEngineVersion(),
+        appVersion: getAppVersion(),
+        appName: app.getName(),
+        logPath: getLogPath(),
+    };
+}

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

@@ -0,0 +1,41 @@
+import fs from 'fs';
+import path from 'path';
+import { app, BrowserWindow } from 'electron';
+import log from 'electron-log';
+class BackendLogger {
+    /** Logs normally but without forwarding to frontend windows */
+    verbose(...params) {
+        console.log(...params);
+    }
+    log(...params) {
+        console.log(...params);
+        BrowserWindow.getAllWindows().forEach(window => {
+            window.webContents.send('log', ...params);
+        });
+    }
+    error(...params) {
+        console.error(...params);
+        BrowserWindow.getAllWindows().forEach(window => {
+            window.webContents.send('error', ...params);
+        });
+    }
+    warn(...params) {
+        console.warn(...params);
+        BrowserWindow.getAllWindows().forEach(window => {
+            window.webContents.send('warn', ...params);
+        });
+    }
+}
+export function getLogPath() {
+    return path.join(app.getPath('userData'), 'logs', `${app.getName()}.log`);
+}
+export function configureLogging() {
+    const logPath = getLogPath();
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    log.transports.file.resolvePathFn = () => logPath;
+    log.initialize();
+    console.log = log.log;
+    console.error = log.error;
+    console.warn = log.warn;
+}
+export const logger = new BackendLogger();