added discussion link

Author: gcclinux

main.cjs

@@ -7,6 +7,7 @@ const { detect } = require('detect-port');
 const defaultPort = 3024;
 const viteDevPort = defaultPort; // Using same port for consistency
 const { shell } = require('electron');
+const { exec } = require('child_process');
 const config = 'easyedit.json';
 const configPath = path.join(app.getPath('userData'), config);
 
@@ -210,6 +211,28 @@ async function handleFileOpen(filePath) {
           resolve();
         });
       } else {
+        // Detect WSL (Windows Subsystem for Linux). In WSL, Linux openers like xdg-open
+        // are often unavailable; prefer calling the Windows host to open the URL.
+        let isWSL = false;
+        try {
+          if (fs.existsSync('/proc/version')) {
+            const ver = fs.readFileSync('/proc/version', 'utf8').toLowerCase();
+            if (ver.indexOf('microsoft') !== -1 || ver.indexOf('wsl') !== -1) isWSL = true;
+          }
+        } catch (wslErr) {
+          // ignore
+        }
+
+        if (isWSL) {
+          try {
+            // Prefer cmd.exe start which opens the default Windows browser from WSL.
+            exec(`cmd.exe /C start "" "${url.replace(/"/g, '\\"')}"`, (e) => { if (e) console.error('Fallback cmd.exe start failed:', e); });
+            return { success: true, fallback: true, wsl: true };
+          } catch (we) {
+            console.error('WSL fallback failed:', we);
+            // continue to general Linux attempts below
+          }
+        }
         mainWindow.webContents.send('file-opened', content);
         resolve();
       }
@@ -250,6 +273,106 @@ function setupIPCHandlers() {
   });
 }
 
+// Support opening external links from renderer safely when running inside Electron
+ipcMain.handle('open-external', async (_event, url) => {
+  // Detect WSL up-front so we can prefer Windows host openers instead of shell.openExternal
+  let isWSL = false;
+  try {
+    if (fs.existsSync('/proc/version')) {
+      const ver = fs.readFileSync('/proc/version', 'utf8').toLowerCase();
+      if (ver.indexOf('microsoft') !== -1 || ver.indexOf('wsl') !== -1) isWSL = true;
+    }
+  } catch (wslErr) {
+    // ignore
+  }
+
+  // If running inside WSL, prefer invoking the Windows cmd.exe to open the URL
+  if (isWSL) {
+    try {
+      // Try plain cmd.exe first (should be available in WSL distros), else try absolute path
+      const tryCmd = (cmd) => new Promise((resolve) => {
+        exec(`${cmd} /C start "" "${url.replace(/"/g, '\\"')}"`, (e) => {
+          if (e) {
+            console.error('WSL cmd fallback failed for', cmd, e);
+            resolve({ success: false, error: String(e) });
+          } else {
+            resolve({ success: true, used: cmd });
+          }
+        });
+      });
+
+      let res = await tryCmd('cmd.exe');
+      if (!res.success) {
+        // common absolute path in WSL mounts
+        const alt = '/mnt/c/Windows/System32/cmd.exe';
+        if (fs.existsSync(alt)) {
+          res = await tryCmd(alt);
+        }
+      }
+      return res;
+    } catch (we) {
+      console.error('WSL open-external fallback failed:', we);
+      return { success: false, error: String(we) };
+    }
+  }
+
+  // Try shell.openExternal first, then fall back to platform commands if necessary.
+  try {
+    await shell.openExternal(url);
+    return { success: true };
+  } catch (err) {
+    console.warn('shell.openExternal failed, attempting platform fallback:', err);
+    // Platform-specific fallbacks
+    try {
+      if (process.platform === 'darwin') {
+        exec(`open "${url}"`, (e) => { if (e) console.error('Fallback open failed:', e); });
+        return { success: true, fallback: true };
+      } else if (process.platform === 'win32') {
+        // start is a shell builtin on Windows; use cmd to run it
+        exec(`cmd /c start "" "${url}"`, (e) => { if (e) console.error('Fallback start failed:', e); });
+        return { success: true, fallback: true };
+      } else {
+        // Linux and other Unix-like: try common openers by absolute path first
+        const candidates = [
+          '/usr/bin/xdg-open',
+          '/bin/xdg-open',
+          '/usr/local/bin/xdg-open',
+          '/usr/bin/gio',
+          '/usr/bin/gnome-open',
+          '/usr/bin/kde-open5'
+        ];
+        let used = false;
+        for (const c of candidates) {
+          try {
+            if (fs.existsSync(c)) {
+              // gio needs different args: 'gio open <url>' works
+              if (c.endsWith('/gio')) {
+                exec(`${c} open "${url}"`, (e) => { if (e) console.error(`Fallback ${c} failed:`, e); });
+              } else {
+                exec(`${c} "${url}"`, (e) => { if (e) console.error(`Fallback ${c} failed:`, e); });
+              }
+              used = true;
+              break;
+            }
+          } catch (fsErr) {
+            // ignore and try next
+          }
+        }
+
+        if (!used) {
+          // Last resort: try xdg-open on PATH (may still fail if missing)
+          exec(`xdg-open "${url}"`, (e) => { if (e) console.error('Fallback xdg-open failed:', e); });
+        }
+
+        return { success: true, fallback: true, usedPath: used };
+      }
+    } catch (err2) {
+      console.error('All methods to open external URL failed:', err2);
+      return { success: false, error: String(err2) };
+    }
+  }
+});
+
 // function createMenuTemplate() {
 //   const menuTemplate = [
 //     {

preload.js

@@ -11,6 +11,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.removeAllListeners('update-preview-spacing');
     }
   },
+  openExternal: (url) => ipcRenderer.invoke('open-external', url),
   getLineHeight: () => ipcRenderer.send('get-line-height'),
   setLineHeight: (callback) => {
     if (callback) {

src/App.tsx

@@ -198,6 +198,7 @@ const App = () => {
     handlePreviewSpacing?: (callback: any) => void;
     getLineHeight?: () => void;
     setLineHeight?: (callback: any) => void;
+    openExternal?: (url: string) => Promise<any>;
   }
 
   // Update the electronAPI declaration
@@ -848,6 +849,39 @@ const App = () => {
                   <div className="hdr-title">Features</div>
                   <div className="hdr-desc">View app features and highlights</div>
                 </button>
+                <div className="hdr-sep" />
+                  <button className="dropdown-item" onClick={async () => {
+                    const url = 'https://github.com/gcclinux/EasyEdit/discussions';
+                    let opened = false;
+                    try {
+                      if (electronAPI && electronAPI.openExternal) {
+                        const res = await electronAPI.openExternal(url);
+                        if (res && res.success) opened = true;
+                        else console.warn('openExternal returned failure:', res);
+                      } else {
+                        const w = window.open(url, '_blank', 'noopener');
+                        if (w) opened = true;
+                      }
+                    } catch (e) {
+                      console.warn('openExternal/window.open threw:', e);
+                    }
+
+                    if (!opened) {
+                      // Try to copy to clipboard as a last-resort fallback and inform the user
+                      try {
+                        await navigator.clipboard.writeText(url);
+                        alert('Unable to open link automatically. The URL has been copied to your clipboard:\n' + url);
+                      } catch (e) {
+                        // If clipboard isn't available, just show the URL to the user
+                        alert('Unable to open or copy link automatically. Please open this URL manually:\n' + url);
+                      }
+                    }
+
+                    setShowHelpDropdown(false);
+                  }}>
+                    <div className="hdr-title">Support</div>
+                    <div className="hdr-desc">Support & Discussion</div>
+                  </button>
               </div>, document.body
             )}
           </div>