@gnsx/genesys.sdk 4.2.9

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

@@ -0,0 +1,369 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { app, BrowserWindow, dialog, Menu, session } from 'electron';
+import isDev from 'electron-is-dev';
+import log from 'electron-log';
+import electronUpdater from 'electron-updater';
+import { getAppInfo } from './handler.js';
+import { configureLogging, logger } from './logging.js';
+import { buildAppMenu } from './menu.js';
+import { configureTelemetry } from './telemetry.js';
+import { GENESYS_LOCAL_URL, GENESYS_URL } from './tools/const.js';
+import { createWindow, parseFeatures } from './window.js';
+const { autoUpdater } = electronUpdater;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export let mainWindow = null;
+// Deep link URL storage
+let pendingDeepLinkUrl = null;
+export function getPendingDeepLinkUrl() {
+    return pendingDeepLinkUrl;
+}
+export function clearPendingDeepLinkUrl() {
+    pendingDeepLinkUrl = null;
+}
+configureTelemetry();
+configureLogging();
+start();
+function start() {
+    // Register deep link protocols
+    registerDeepLinkProtocols();
+    const hasLock = app.requestSingleInstanceLock();
+    app.on('second-instance', (event, argv, workingDirectory, additionalData) => {
+        logger.log('🔗 [deep-link] Second instance detected, checking for deep link URL');
+        // Handle deep link from second instance
+        const deepLinkUrl = getDeepLinkFromArgs(argv);
+        if (deepLinkUrl) {
+            logger.log('🔗 [deep-link] Processing URL from second instance:', deepLinkUrl);
+            handleDeepLink(deepLinkUrl);
+        }
+        if (mainWindow) {
+            mainWindow.isMinimized() && mainWindow.restore();
+            mainWindow.focus();
+        }
+    });
+    if (!hasLock) {
+        return app.quit();
+    }
+    // Handle deep link from first instance
+    const deepLinkUrl = getDeepLinkFromArgs(process.argv);
+    if (deepLinkUrl) {
+        logger.log('🔗 [deep-link] Processing URL from first instance:', deepLinkUrl);
+        pendingDeepLinkUrl = deepLinkUrl;
+    }
+    // Get custom URL from command line arguments (--url=https://example.com)
+    const customUrl = app.commandLine.hasSwitch('url') ? app.commandLine.getSwitchValue('url') : undefined;
+    if (customUrl) {
+        logger.log('Custom URL provided:', customUrl);
+    }
+    logger.log('===============================================');
+    logger.log(`\n${JSON.stringify(getAppInfo(), null, 2)}`);
+    logger.log('===============================================');
+    // Handle macOS deep links
+    app.on('open-url', (event, url) => {
+        event.preventDefault();
+        logger.log('🔗 [deep-link] macOS open-url event:', url);
+        handleDeepLink(url);
+    });
+    app.whenReady().then(async () => {
+        await initMainWindow();
+        Menu.setApplicationMenu(buildAppMenu(mainWindow));
+        checkForUpdates();
+        // Process pending deep link after window is ready
+        if (pendingDeepLinkUrl) {
+            logger.log('🔗 [deep-link] Processing pending deep link URL:', pendingDeepLinkUrl);
+            handleDeepLink(pendingDeepLinkUrl);
+            pendingDeepLinkUrl = null;
+        }
+    });
+    app.on('window-all-closed', () => {
+        if (process.platform !== 'darwin')
+            app.quit();
+    });
+}
+/** Register deep link protocols based on environment */
+function registerDeepLinkProtocols() {
+    const protocol = isDev ? 'genesys-dev' : 'genesys';
+    let success = false;
+    if (process.defaultApp) {
+        // Development mode - need to specify execPath and argv
+        if (process.argv.length >= 2) {
+            success = app.setAsDefaultProtocolClient(protocol, process.execPath, [path.resolve(process.argv[1])]);
+        }
+    }
+    else {
+        // Production mode - simple registration
+        success = app.setAsDefaultProtocolClient(protocol);
+    }
+    if (success) {
+        logger.log(`🔗 [deep-link] Successfully registered protocol: ${protocol}://`);
+    }
+    else {
+        logger.warn(`⚠️ [deep-link] Failed to register protocol: ${protocol}://`);
+    }
+}
+/** Extract deep link URL from command line arguments */
+function getDeepLinkFromArgs(argv) {
+    const protocol = isDev ? 'genesys-dev://' : 'genesys://';
+    for (const arg of argv) {
+        if (arg.startsWith(protocol)) {
+            return arg;
+        }
+    }
+    return null;
+}
+/** Handle deep link URL */
+function handleDeepLink(url) {
+    logger.log('🔗 [deep-link] Handling deep link:', url);
+    try {
+        const parsedUrl = new URL(url);
+        logger.log('🔗 [deep-link] Parsed URL:', parsedUrl.toString());
+        // Send deep link to renderer process if window is ready
+        if (mainWindow && !mainWindow.isDestroyed()) {
+            mainWindow.webContents.send('deep-link', parsedUrl.toString());
+            logger.log('🔗 [deep-link] Deep link sent to renderer process');
+        }
+        else {
+            // Store for later if window isn't ready
+            pendingDeepLinkUrl = url;
+            logger.log('🔗 [deep-link] Window not ready, storing deep link for later');
+        }
+    }
+    catch (error) {
+        logger.error('❌ [deep-link] Failed to parse deep link URL:', error);
+    }
+}
+const windowOptions = {
+    backgroundColor: '#13171b',
+    hasShadow: true,
+    titleBarStyle: 'hidden',
+    titleBarOverlay: false,
+    minWidth: 1024,
+    minHeight: 720,
+};
+async function showLocalDevError() {
+    const result = await dialog.showMessageBox(mainWindow, {
+        type: 'error',
+        buttons: ['Refresh (Ctrl+Shift+R)', 'OK'],
+        title: 'Local Development Server Not Running',
+        message: 'Failed to connect to local development server',
+        detail: 'Run "pnpm dev" on the .ai project and then refresh this page'
+    });
+    if (result.response === 0) {
+        // Refresh the page
+        try {
+            await mainWindow.loadURL(GENESYS_LOCAL_URL);
+            logger.log('Genesys.ai localhost');
+        }
+        catch (error) {
+            logger.error('Failed to load local URL:', error);
+            await showLocalDevError();
+        }
+    }
+}
+async function showUrlLoadError(message) {
+    await dialog.showMessageBox(mainWindow, {
+        type: 'error',
+        buttons: ['OK'],
+        title: 'Connection Error',
+        message,
+        detail: 'Please check your internet connection and try again'
+    });
+}
+async function initMainWindow() {
+    // Create main window with title bar overlay
+    mainWindow = createWindow('main', {
+        show: false,
+        title: 'Genesys',
+        ...windowOptions,
+        webPreferences: {
+            sandbox: true,
+            contextIsolation: true,
+            preload: path.join(__dirname, '../../../preload/electron/preload.js'),
+            nodeIntegration: false,
+        },
+    });
+    mainWindow.webContents.on('did-finish-load', async () => {
+        logger.log('🌐 Website loaded successfully...');
+        if (isDev && !extensionsLoaded) {
+            await loadDevExtensions();
+        }
+        mainWindow.show();
+    });
+    // Options for new windows
+    mainWindow.webContents.setWindowOpenHandler(({ url, frameName, features }) => {
+        const parsedFeatures = parseFeatures(features);
+        logger.log('Open window', url, features, parsedFeatures);
+        return {
+            action: 'allow',
+            createWindow: (options) => {
+                const newWindow = new BrowserWindow(options);
+                newWindow.setMenu(null); // Remove menu bar
+                return newWindow.webContents;
+            },
+            overrideBrowserWindowOptions: {
+                ...windowOptions,
+                titleBarOverlay: (process.platform === 'darwin') ? false : {
+                    color: '#13171b',
+                    symbolColor: '#FFFFFF',
+                    height: 44,
+                },
+                minWidth: 800,
+                minHeight: 600,
+                width: parsedFeatures.width,
+                height: parsedFeatures.height,
+                fullscreen: parsedFeatures.fullscreen,
+                title: parsedFeatures.title,
+            }
+        };
+    });
+    // Get custom URL from command line arguments
+    const customUrl = process.argv.find(arg => arg.startsWith('--url='))?.split('=')[1];
+    if (customUrl) {
+        try {
+            await mainWindow.loadURL(customUrl);
+            logger.log('Loading custom URL:', customUrl);
+        }
+        catch (error) {
+            logger.error('Failed to load custom URL:', error);
+            await showUrlLoadError('Failed to load custom URL');
+        }
+    }
+    else if (isDev) {
+        if (process.env.DEV_HOSTED) {
+            try {
+                await mainWindow.loadURL(GENESYS_URL);
+                logger.log('Genesys.ai hosted');
+            }
+            catch (error) {
+                logger.error('Failed to load hosted URL:', error);
+                await showUrlLoadError('Failed to load hosted Genesys.ai');
+            }
+        }
+        else {
+            try {
+                await mainWindow.loadURL(GENESYS_LOCAL_URL);
+                logger.log('Genesys.ai localhost');
+            }
+            catch (error) {
+                logger.error('Failed to load local URL:', error);
+                await showLocalDevError();
+            }
+        }
+        mainWindow.webContents.openDevTools();
+    }
+    else {
+        try {
+            await mainWindow.loadURL(GENESYS_URL);
+        }
+        catch (error) {
+            logger.error('Failed to load production URL:', error);
+            await showUrlLoadError('Failed to load Genesys.ai');
+        }
+    }
+}
+;
+function checkForUpdates() {
+    // Check for GH_TOKEN environment variable
+    if (!process.env.GH_TOKEN) {
+        logger.warn('GH_TOKEN environment variable is missing - update check will be skipped');
+        dialog.showMessageBox({
+            type: 'warning',
+            buttons: ['OK'],
+            title: 'Update Check Warning',
+            message: 'GitHub Token Missing',
+            detail: 'The GH_TOKEN environment variable is not set.\n\nUpdate checks require a GitHub token to access private releases.\n\nPlease set the GH_TOKEN environment variable and restart the application to enable automatic updates.',
+        });
+        return;
+    }
+    autoUpdater.logger = log;
+    autoUpdater.checkForUpdatesAndNotify();
+    autoUpdater.on('update-available', () => {
+        logger.log('App update available');
+        mainWindow?.webContents.send('update_available');
+    });
+    autoUpdater.on('update-downloaded', info => {
+        const currentVersion = app.getVersion();
+        logger.log(`App update downloaded: v${currentVersion} -> v${info.version}`);
+        dialog.showMessageBox(mainWindow, {
+            type: 'info',
+            buttons: ['Restart', 'Later'],
+            title: 'SDK App Update Ready',
+            message: `Update to v${info.version} is ready to install`,
+            detail: `Current version: v${currentVersion}\nNew version: v${info.version}\n\nRestart now to complete the update?`,
+        }).then(({ response }) => {
+            if (response === 0)
+                autoUpdater.quitAndInstall();
+        });
+    });
+    autoUpdater.on('error', (error) => {
+        logger.error('Update error:', error);
+    });
+}
+let extensionsLoaded = false;
+// Chrome Web Store extension IDs
+const REACT_DEVELOPER_TOOLS_ID = 'fmkadmapgofadopljbjfkapdkoienihi';
+const MOBX_DEVTOOLS_ID = 'pfgnfdagidkfgccljigdamigbcnndkod';
+/** Get the path where Electron stores downloaded extensions */
+function getExtensionsPath() {
+    return path.join(app.getPath('userData'), 'extensions');
+}
+/** Check if an extension is already downloaded */
+function isExtensionDownloaded(extensionId) {
+    const extensionPath = path.join(getExtensionsPath(), extensionId);
+    return fs.existsSync(extensionPath);
+}
+/** Download extension using electron-devtools-installer (uses deprecated API but only for download) */
+async function downloadExtension(extensionId, name) {
+    try {
+        // Dynamic import to avoid loading the module if not needed
+        const { installExtension } = await import('electron-devtools-installer');
+        await installExtension(extensionId);
+        logger.log(`🔧 Downloaded extension: ${name}`);
+        return path.join(getExtensionsPath(), extensionId);
+    }
+    catch (err) {
+        logger.log(`❌ Failed to download ${name}:`, err);
+        return null;
+    }
+}
+/** Load an extension using the new session.extensions API */
+async function loadExtensionFromPath(extensionPath, name) {
+    try {
+        const extension = await session.defaultSession.extensions.loadExtension(extensionPath, { allowFileAccess: true });
+        logger.log(`🔧 Loaded extension: ${extension.name}`);
+        return true;
+    }
+    catch (err) {
+        logger.log(`❌ Failed to load ${name}:`, err);
+        return false;
+    }
+}
+/** Load development extensions only once after website loads successfully */
+async function loadDevExtensions() {
+    // Only load extensions in dev mode or when explicitly enabled
+    if (!isDev && !app.commandLine.hasSwitch('devtoolextensions')) {
+        return;
+    }
+    if (app.commandLine.hasSwitch('devtoolextensions') && app.commandLine.getSwitchValue('devtoolextensions') === '0') {
+        return;
+    }
+    const extensions = [
+        { id: REACT_DEVELOPER_TOOLS_ID, name: 'React Developer Tools' },
+        { id: MOBX_DEVTOOLS_ID, name: 'MobX Developer Tools' },
+    ];
+    for (const ext of extensions) {
+        const extensionPath = path.join(getExtensionsPath(), ext.id);
+        // If extension is not downloaded, download it first (uses deprecated API internally)
+        if (!isExtensionDownloaded(ext.id)) {
+            const downloadedPath = await downloadExtension(ext.id, ext.name);
+            if (!downloadedPath)
+                continue;
+        }
+        // Load using new API
+        await loadExtensionFromPath(extensionPath, ext.name);
+    }
+    extensionsLoaded = true;
+    logger.log('🔧 Extension loading completed.');
+}

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

@@ -0,0 +1,196 @@
+import { app, Menu } from 'electron';
+import { checkUpdates, openAppLog, showAbout, showInExplorer } from './actions.js';
+export function buildAppMenu(mainWindow) {
+    const isMac = process.platform === 'darwin';
+    if (isMac) {
+        return buildMacMenu(mainWindow);
+    }
+    return buildWindowsMenu(mainWindow);
+}
+function buildMacMenu(mainWindow) {
+    const menuTemplate = [
+        {
+            label: app.name,
+            submenu: [
+                {
+                    label: `About ${app.name}`,
+                    click: () => showAbout(mainWindow)
+                },
+                { type: 'separator' },
+                {
+                    label: 'Check for Updates',
+                    click: checkUpdates
+                },
+                { type: 'separator' },
+                { role: 'services' },
+                { type: 'separator' },
+                { role: 'hide' },
+                { role: 'hideOthers' },
+                { role: 'unhide' },
+                { type: 'separator' },
+                {
+                    label: `Quit ${app.name}`,
+                    accelerator: 'Cmd+Q',
+                    click: () => app.quit()
+                }
+            ]
+        },
+        {
+            label: 'Project',
+            submenu: [
+                {
+                    label: 'Show in Finder',
+                    accelerator: 'Cmd+E',
+                    click: showInExplorer
+                }
+            ]
+        },
+        {
+            label: 'Edit',
+            submenu: [
+                { label: 'Undo', role: 'undo' },
+                { label: 'Redo', role: 'redo' },
+                { type: 'separator' },
+                { label: 'Cut', role: 'cut' },
+                { label: 'Copy', role: 'copy' },
+                { label: 'Paste', role: 'paste' },
+                { label: 'Paste and Match Style', role: 'pasteAndMatchStyle' },
+                { label: 'Delete', role: 'delete' },
+                { label: 'Select All', role: 'selectAll' }
+            ]
+        },
+        {
+            label: 'View',
+            submenu: [
+                {
+                    label: 'Reload',
+                    accelerator: 'Cmd+R',
+                    click: () => mainWindow?.reload()
+                },
+                {
+                    label: 'Force Reload',
+                    accelerator: 'Cmd+Shift+R',
+                    click: () => mainWindow?.webContents.reloadIgnoringCache()
+                },
+                { type: 'separator' },
+                { label: 'Actual Size', role: 'resetZoom' },
+                { label: 'Zoom In', role: 'zoomIn' },
+                { label: 'Zoom Out', role: 'zoomOut' },
+                { type: 'separator' },
+                { label: 'Toggle Full Screen', role: 'togglefullscreen' },
+                {
+                    label: 'Toggle Full Screen',
+                    accelerator: 'F11',
+                    visible: false,
+                    click: () => mainWindow?.setFullScreen(!mainWindow.isFullScreen())
+                }
+            ]
+        },
+        {
+            label: 'Tools',
+            submenu: [
+                {
+                    label: 'Toggle Developer Console',
+                    accelerator: 'F12',
+                    click: () => mainWindow?.webContents.toggleDevTools()
+                },
+                { type: 'separator' },
+                {
+                    label: 'Open App Log',
+                    click: openAppLog
+                }
+            ]
+        }
+    ];
+    return Menu.buildFromTemplate(menuTemplate);
+}
+function buildWindowsMenu(mainWindow) {
+    const menuTemplate = [
+        {
+            label: 'Project',
+            submenu: [
+                {
+                    label: 'Show in Explorer',
+                    accelerator: 'Ctrl+E',
+                    click: showInExplorer
+                }
+            ]
+        },
+        {
+            label: 'Edit',
+            submenu: [
+                { label: 'Undo', role: 'undo' },
+                { label: 'Redo', role: 'redo' },
+                { type: 'separator' },
+                { label: 'Cut', role: 'cut' },
+                { label: 'Copy', role: 'copy' },
+                { label: 'Paste', role: 'paste' },
+                { label: 'Paste and Match Style', role: 'pasteAndMatchStyle' },
+                { label: 'Delete', role: 'delete' },
+                { label: 'Select All', role: 'selectAll' }
+            ]
+        },
+        {
+            label: 'View',
+            submenu: [
+                {
+                    label: 'Reload',
+                    accelerator: 'Ctrl+R',
+                    click: () => mainWindow?.reload()
+                },
+                {
+                    label: 'Force Reload',
+                    accelerator: 'Ctrl+Shift+R',
+                    click: () => mainWindow?.webContents.reloadIgnoringCache()
+                },
+                { type: 'separator' },
+                {
+                    label: 'Toggle Developer Console',
+                    accelerator: 'F12',
+                    click: () => mainWindow?.webContents.toggleDevTools()
+                },
+                { type: 'separator' },
+                { label: 'Actual Size', role: 'resetZoom' },
+                { label: 'Zoom In', role: 'zoomIn' },
+                { label: 'Zoom Out', role: 'zoomOut' },
+                { type: 'separator' },
+                { label: 'Toggle Full Screen', role: 'togglefullscreen', accelerator: 'F11' }
+            ]
+        },
+        {
+            label: 'Tools',
+            submenu: [
+                {
+                    label: 'Check for Updates',
+                    click: checkUpdates
+                },
+                { type: 'separator' },
+                {
+                    label: 'Open App Log',
+                    click: openAppLog
+                }
+            ]
+        },
+        {
+            label: 'Help',
+            submenu: [
+                {
+                    label: `About ${app.name}`,
+                    click: () => showAbout(mainWindow)
+                }
+            ]
+        },
+        {
+            label: '',
+            submenu: [
+                {
+                    label: `Quit ${app.name}`,
+                    accelerator: 'Ctrl+Q',
+                    click: () => app.quit()
+                }
+            ],
+            visible: false
+        }
+    ];
+    return Menu.buildFromTemplate(menuTemplate);
+}