shell api migration to electron

Author: abose

src-electron/main-window-ipc.js

@@ -1,5 +1,6 @@
-const { ipcMain, BrowserWindow } = require('electron');
+const { ipcMain, BrowserWindow, shell, clipboard } = require('electron');
 const path = require('path');
+const { spawn } = require('child_process');
 
 const PHOENIX_WINDOW_PREFIX = 'phcode-';
 const PHOENIX_EXTENSION_WINDOW_PREFIX = 'extn-';
@@ -20,13 +21,27 @@ function getNextLabel(prefix) {
     throw new Error(`No free window label available for prefix: ${prefix}`);
 }
 
+// Track close handlers per window
+const windowCloseHandlers = new Map();
+
 function registerWindow(win, label) {
     windowRegistry.set(label, win);
     webContentsToLabel.set(win.webContents.id, label);
 
     win.on('closed', () => {
         windowRegistry.delete(label);
         webContentsToLabel.delete(win.webContents.id);
+        windowCloseHandlers.delete(win.webContents.id);
+    });
+}
+
+function setupCloseHandler(win) {
+    win.on('close', (event) => {
+        const hasHandler = windowCloseHandlers.get(win.webContents.id);
+        if (hasHandler && !win.forceClose) {
+            event.preventDefault();
+            win.webContents.send('close-requested');
+        }
     });
 }
 
@@ -95,6 +110,138 @@ function registerWindowIpcHandlers() {
             win.focus();
         }
     });
+
+    // Get process ID
+    ipcMain.handle('get-process-id', () => {
+        return process.pid;
+    });
+
+    // Get platform architecture
+    ipcMain.handle('get-platform-arch', () => {
+        return process.arch;
+    });
+
+    // Get current working directory
+    ipcMain.handle('get-cwd', () => {
+        return process.cwd();
+    });
+
+    // Fullscreen APIs
+    ipcMain.handle('is-fullscreen', (event) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        return win ? win.isFullScreen() : false;
+    });
+
+    ipcMain.handle('set-fullscreen', (event, enable) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (win) {
+            win.setFullScreen(enable);
+        }
+    });
+
+    // Window title APIs
+    ipcMain.handle('set-window-title', (event, title) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (win) {
+            win.setTitle(title);
+        }
+    });
+
+    ipcMain.handle('get-window-title', (event) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        return win ? win.getTitle() : '';
+    });
+
+    // Clipboard APIs
+    ipcMain.handle('clipboard-read-text', () => {
+        return clipboard.readText();
+    });
+
+    ipcMain.handle('clipboard-write-text', (event, text) => {
+        clipboard.writeText(text);
+    });
+
+    // Read file paths from clipboard (platform-specific)
+    ipcMain.handle('clipboard-read-files', () => {
+        const formats = clipboard.availableFormats();
+
+        // Windows: FileNameW format contains file paths
+        if (process.platform === 'win32' && formats.includes('FileNameW')) {
+            const buffer = clipboard.readBuffer('FileNameW');
+            // FileNameW is null-terminated UTF-16LE string
+            const paths = buffer.toString('utf16le').split('\0').filter(p => p.length > 0);
+            return paths;
+        }
+
+        // macOS: public.file-url format
+        if (process.platform === 'darwin') {
+            // Try reading as file URLs
+            const text = clipboard.read('public.file-url');
+            if (text) {
+                // Convert file:// URLs to paths
+                const paths = text.split('\n')
+                    .filter(url => url.startsWith('file://'))
+                    .map(url => decodeURIComponent(url.replace('file://', '')));
+                if (paths.length > 0) {
+                    return paths;
+                }
+            }
+        }
+
+        // Linux: text/uri-list format
+        if (process.platform === 'linux' && formats.includes('text/uri-list')) {
+            const text = clipboard.read('text/uri-list');
+            if (text) {
+                const paths = text.split('\n')
+                    .filter(url => url.startsWith('file://'))
+                    .map(url => decodeURIComponent(url.replace('file://', '')));
+                if (paths.length > 0) {
+                    return paths;
+                }
+            }
+        }
+
+        return null;
+    });
+
+    // Shell APIs
+    ipcMain.handle('move-to-trash', async (event, platformPath) => {
+        await shell.trashItem(platformPath);
+    });
+
+    ipcMain.handle('show-in-folder', (event, platformPath) => {
+        shell.showItemInFolder(platformPath);
+    });
+
+    ipcMain.handle('open-external', async (event, url) => {
+        await shell.openExternal(url);
+    });
+
+    // Windows-only: open URL in specific browser (fire and forget)
+    ipcMain.handle('open-url-in-browser-win', (event, url, browser) => {
+        if (process.platform !== 'win32') {
+            throw new Error('open-url-in-browser-win is only supported on Windows');
+        }
+        spawn('cmd', ['/c', 'start', browser, url], { shell: true, detached: true, stdio: 'ignore' });
+    });
+
+    // Register close handler for current window
+    ipcMain.handle('register-close-handler', (event) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (win) {
+            windowCloseHandlers.set(win.webContents.id, true);
+            setupCloseHandler(win);
+        }
+    });
+
+    // Allow close after handler approves
+    ipcMain.handle('allow-close', (event) => {
+        const win = BrowserWindow.fromWebContents(event.sender);
+        if (win) {
+            win.forceClose = true;
+            win.close();
+        }
+    });
 }
 
-module.exports = { registerWindowIpcHandlers, registerWindow, windowRegistry };
+module.exports = { registerWindowIpcHandlers, registerWindow, setupCloseHandler, windowRegistry };

src-electron/preload.js

@@ -95,5 +95,34 @@ contextBridge.exposeInMainWorld('electronAPI', {
     createPhoenixWindow: (url, options) => ipcRenderer.invoke('create-phoenix-window', url, options),
     closeWindow: () => ipcRenderer.invoke('close-window'),
     quitApp: (exitCode) => ipcRenderer.invoke('quit-app', exitCode),
-    focusWindow: () => ipcRenderer.invoke('focus-window')
+    focusWindow: () => ipcRenderer.invoke('focus-window'),
+
+    // Process and platform info
+    getProcessId: () => ipcRenderer.invoke('get-process-id'),
+    getPlatformArch: () => ipcRenderer.invoke('get-platform-arch'),
+    getCwd: () => ipcRenderer.invoke('get-cwd'),
+
+    // Fullscreen APIs
+    isFullscreen: () => ipcRenderer.invoke('is-fullscreen'),
+    setFullscreen: (enable) => ipcRenderer.invoke('set-fullscreen', enable),
+
+    // Window title APIs
+    setWindowTitle: (title) => ipcRenderer.invoke('set-window-title', title),
+    getWindowTitle: () => ipcRenderer.invoke('get-window-title'),
+
+    // Clipboard APIs
+    clipboardReadText: () => ipcRenderer.invoke('clipboard-read-text'),
+    clipboardWriteText: (text) => ipcRenderer.invoke('clipboard-write-text', text),
+    clipboardReadFiles: () => ipcRenderer.invoke('clipboard-read-files'),
+
+    // Shell APIs
+    moveToTrash: (platformPath) => ipcRenderer.invoke('move-to-trash', platformPath),
+    showInFolder: (platformPath) => ipcRenderer.invoke('show-in-folder', platformPath),
+    openExternal: (url) => ipcRenderer.invoke('open-external', url),
+    openUrlInBrowserWin: (url, browser) => ipcRenderer.invoke('open-url-in-browser-win', url, browser),
+
+    // Close requested handler
+    onCloseRequested: (callback) => ipcRenderer.on('close-requested', () => callback()),
+    registerCloseHandler: () => ipcRenderer.invoke('register-close-handler'),
+    allowClose: () => ipcRenderer.invoke('allow-close')
 });