Fix: Windows and Linux compatibility for dialogs, terminal, and CLI detection

- Linux: add re-entrancy guard on file dialogs + XDG portal pre-warming
- Windows: replace lsof with netstat for port conflict recovery
- Windows: terminal fallback spawns cmd.exe directly (no Unix script/dev/null)
- Windows: CLI detection uses 'where' instead of 'which', adds Windows paths
- Cross-platform: replace curl with Node http.get for LLM service detection
- Cross-platform: fix path.split('/') → split(/[\\/]/) in 6 renderer locations

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: ozgesolidkey

src/main/api-server.ts

@@ -774,10 +774,17 @@ export function startApiServer(ctx: ApiContext): void {
           }
         );
         shutdownReq.on('error', () => {
-          // Old instance not responding — force kill via lsof
+          // Old instance not responding — force kill the process holding the port
           try {
             const { execSync } = require('child_process');
-            const pid = execSync(`lsof -ti:${API_PORT} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+            let pid = '';
+            if (process.platform === 'win32') {
+              const out = execSync(`netstat -ano | findstr :${API_PORT} | findstr LISTENING`, { encoding: 'utf-8' }).trim();
+              const match = out.split('\n')[0]?.trim().split(/\s+/).pop();
+              if (match) pid = match;
+            } else {
+              pid = execSync(`lsof -ti:${API_PORT} 2>/dev/null`, { encoding: 'utf-8' }).trim();
+            }
             if (pid) {
               console.log(`Killing old process ${pid} on port ${API_PORT}`);
               process.kill(parseInt(pid), 'SIGTERM');

src/main/index.ts

@@ -745,6 +745,20 @@ app.whenReady().then(() => {
   ensureConfigDir();
   createWindow();
 
+  // On Linux, pre-warm the XDG desktop portal so the first file-open dialog
+  // is responsive immediately. Without this, the portal's D-Bus service may
+  // not be activated yet, causing the file chooser widget to appear but not
+  // accept clicks until the service finishes initializing.
+  if (process.platform === 'linux') {
+    try {
+      spawn('gdbus', [
+        'introspect', '--session',
+        '--dest', 'org.freedesktop.portal.Desktop',
+        '--object-path', '/org/freedesktop/portal/desktop',
+      ], { stdio: 'ignore' }).unref();
+    } catch { /* non-critical — dialog still works on retry */ }
+  }
+
   // Check if launched with a file path argument (e.g. `logan myfile.log`)
   const cliFilePath = extractFilePathFromArgv(process.argv);
   if (cliFilePath && mainWindow) {
@@ -1920,16 +1934,28 @@ ipcMain.handle(IPC.SSH_DOWNLOAD_FILE, async (_, remotePath: string) => {
 // On Linux, passing a parent BrowserWindow to dialog.show*Dialog causes the
 // dialog to attach modally via XDG portal / GTK, which can deadlock and leave
 // the window unresponsive. Calling the parentless overload avoids this entirely.
+// A re-entrancy guard prevents stacking multiple native dialogs (which on Linux
+// can leave a dialog visible but non-interactive until the earlier one resolves).
+let _dialogOpen = false;
+const _cancelledResult: Electron.OpenDialogReturnValue = { canceled: true, filePaths: [] };
+const _cancelledSaveResult: Electron.SaveDialogReturnValue = { canceled: true, filePath: '' };
+
 function showOpenDialog(options: Electron.OpenDialogOptions): Promise<Electron.OpenDialogReturnValue> {
-  return process.platform === 'linux' || !mainWindow
+  if (_dialogOpen) return Promise.resolve(_cancelledResult);
+  _dialogOpen = true;
+  const p = process.platform === 'linux' || !mainWindow
     ? dialog.showOpenDialog(options)
     : dialog.showOpenDialog(mainWindow, options);
+  return p.finally(() => { _dialogOpen = false; });
 }
 
 function showSaveDialog(options: Electron.SaveDialogOptions): Promise<Electron.SaveDialogReturnValue> {
-  return process.platform === 'linux' || !mainWindow
+  if (_dialogOpen) return Promise.resolve(_cancelledSaveResult);
+  _dialogOpen = true;
+  const p = process.platform === 'linux' || !mainWindow
     ? dialog.showSaveDialog(options)
     : dialog.showSaveDialog(mainWindow, options);
+  return p.finally(() => { _dialogOpen = false; });
 }
 
 ipcMain.handle(IPC.OPEN_FILE_DIALOG, async () => {
@@ -5115,21 +5141,24 @@ ipcMain.handle(IPC.TERMINAL_CREATE_LOCAL, async (_, sessionId: string, options?:
       return { success: true, label: 'Local' };
     }
 
-    // Fallback for Linux (no node-pty): use `script` to wrap the shell
-    // in a real PTY. `script -qfc <cmd> /dev/null` is portable across
-    // util-linux and BSD `script` implementations.
+    // Fallback (no node-pty): spawn the shell directly as a child process.
+    // On Linux, wrap with `script` for PTY emulation when available.
+    // On Windows, cmd.exe / powershell work fine without PTY wrapping.
     const env = { ...process.env, TERM: 'xterm-256color', COLUMNS: String(cols), LINES: String(rows) };
     let scriptCmd: string;
     let scriptArgs: string[];
-    try {
-      execSync('which script', { timeout: 1000 });
-      // util-linux script: -q quiet, -f flush, -c command, /dev/null = no typescript file
-      scriptCmd = 'script';
-      scriptArgs = ['-qfc', shellPath, '/dev/null'];
-    } catch {
-      // No `script` available — fall back to direct bash (will have echo issues but works)
+    if (process.platform === 'win32') {
       scriptCmd = shellPath;
-      scriptArgs = ['-i'];
+      scriptArgs = [];
+    } else {
+      try {
+        execSync('which script', { timeout: 1000 });
+        scriptCmd = 'script';
+        scriptArgs = ['-qfc', shellPath, '/dev/null'];
+      } catch {
+        scriptCmd = shellPath;
+        scriptArgs = ['-i'];
+      }
     }
     const child = spawn(scriptCmd, scriptArgs, { cwd, env, stdio: ['pipe', 'pipe', 'pipe'] });
 
@@ -5510,19 +5539,23 @@ function getBuiltinScriptPath(): string {
 }
 
 function findClaudeCli(): string | null {
-  // Try PATH first
+  const whichCmd = process.platform === 'win32' ? 'where claude' : 'which claude';
   try {
-    const result = execSync('which claude', { timeout: 3000, encoding: 'utf-8' }).trim();
+    const result = execSync(whichCmd, { timeout: 3000, encoding: 'utf-8' }).trim().split('\n')[0];
     if (result) return result;
   } catch { /* not in PATH */ }
-  // Common install locations
-  const candidates = [
-    path.join(os.homedir(), '.claude', 'bin', 'claude'),
-    '/usr/local/bin/claude',
-    '/opt/homebrew/bin/claude',
-  ];
+  const candidates = process.platform === 'win32'
+    ? [
+        path.join(os.homedir(), '.claude', 'bin', 'claude.exe'),
+        path.join(process.env.LOCALAPPDATA || '', 'Programs', 'claude', 'claude.exe'),
+      ]
+    : [
+        path.join(os.homedir(), '.claude', 'bin', 'claude'),
+        '/usr/local/bin/claude',
+        '/opt/homebrew/bin/claude',
+      ];
   for (const p of candidates) {
-    if (fs.existsSync(p)) return p;
+    if (p && fs.existsSync(p)) return p;
   }
   return null;
 }
@@ -5723,7 +5756,9 @@ ipcMain.handle('agent-detect-environment', async () => {
         '/opt/homebrew/bin/claude',
         path.join(os.homedir(), '.nvm', 'versions', 'node', 'current', 'bin', 'claude'),
       ],
-      aider: ['/usr/local/bin/aider', path.join(os.homedir(), '.local', 'bin', 'aider')],
+      aider: process.platform === 'win32'
+        ? [path.join(os.homedir(), '.local', 'bin', 'aider.exe')]
+        : ['/usr/local/bin/aider', path.join(os.homedir(), '.local', 'bin', 'aider')],
     }[bin] ?? [];
     for (const p of extra) {
       if (!fs.existsSync(p)) continue;
@@ -5744,14 +5779,24 @@ ipcMain.handle('agent-detect-environment', async () => {
   const builtinPath = path.join(app.getAppPath(), 'examples', 'agent-node.mjs');
   const hasBuiltin = fs.existsSync(builtinPath);
 
-  // Detect local LLM services
+  // Detect local LLM services (use Node http instead of curl for cross-platform)
   let hasOllama = false;
   let ollamaModels: string[] = [];
   let hasLmStudio = false;
 
+  const httpGet = (url: string, timeoutMs: number): Promise<string> => new Promise((resolve, reject) => {
+    const req = require('http').get(url, { timeout: timeoutMs }, (res: any) => {
+      let body = '';
+      res.on('data', (chunk: string) => { body += chunk; });
+      res.on('end', () => resolve(body));
+    });
+    req.on('error', reject);
+    req.on('timeout', () => { req.destroy(); reject(new Error('timeout')); });
+  });
+
   // Check Ollama (port 11434)
   try {
-    const ollamaResp = execSync('curl -sf http://localhost:11434/api/tags 2>/dev/null', { timeout: 3000, encoding: 'utf-8' });
+    const ollamaResp = await httpGet('http://localhost:11434/api/tags', 3000);
     const data = JSON.parse(ollamaResp);
     if (data.models?.length > 0) {
       hasOllama = true;
@@ -5761,7 +5806,7 @@ ipcMain.handle('agent-detect-environment', async () => {
 
   // Check LM Studio (port 1234)
   try {
-    const lmsResp = execSync('curl -sf http://localhost:1234/v1/models 2>/dev/null', { timeout: 3000, encoding: 'utf-8' });
+    const lmsResp = await httpGet('http://localhost:1234/v1/models', 3000);
     const data = JSON.parse(lmsResp);
     if (data.data?.length > 0) {
       hasLmStudio = true;
@@ -5943,7 +5988,7 @@ ipcMain.handle(IPC.READ_FILE_TEXT, async (_event, filePath: string) => {
 });
 
 ipcMain.handle('agent-browse-script', async () => {
-  const result = await dialog.showOpenDialog({
+  const result = await showOpenDialog({
     title: 'Select Agent Script',
     filters: [
       { name: 'Scripts', extensions: ['mjs', 'js', 'ts', 'sh', 'py'] },

src/renderer/renderer.ts

@@ -4369,7 +4369,7 @@ async function toggleRecentFilesPopup(): Promise<void> {
   } else {
     html += `<div class="recent-files-list">`;
     for (const f of files) {
-      const name = f.path.split('/').pop() || f.path;
+      const name = f.path.split(/[\\/]/).pop() || f.path;
       const dir = f.path.substring(0, f.path.length - name.length - 1);
       const ageMs = Date.now() - f.lastOpened;
       let ageText: string;
@@ -4519,7 +4519,7 @@ async function openFolder(): Promise<void> {
 
   const result = await window.api.readFolder(folderPath);
   if (result.success && result.files) {
-    const folderName = folderPath.split('/').pop() || folderPath;
+    const folderName = folderPath.split(/[\\/]/).pop() || folderPath;
     state.folders.push({
       path: folderPath,
       name: folderName,
@@ -8407,7 +8407,7 @@ function loadVideoFromPath(videoPath: string): void {
   state.videoFilePath = videoPath;
   elements.videoElement.src = 'file://' + videoPath;
   elements.videoContainer.classList.add('has-video');
-  const fileName = videoPath.split('/').pop() || videoPath;
+  const fileName = videoPath.split(/[\\/]/).pop() || videoPath;
   elements.videoFileName.textContent = fileName;
   saveVideoState();
 }
@@ -13551,7 +13551,7 @@ function openImageInPanel(filePath: string): void {
   imageViewerImg.style.display = 'none';
   if (imageDropZone) imageDropZone.style.display = 'none';
 
-  const fileName = filePath.split('/').pop() || filePath;
+  const fileName = filePath.split(/[\\/]/).pop() || filePath;
   if (imageFileNameEl) imageFileNameEl.textContent = fileName;
 
   imageViewerImg.onload = () => {
@@ -13602,7 +13602,7 @@ let currentDiagramPath = '';
 function openDiagramInPanel(filePath: string): void {
   currentDiagramPath = filePath;
   const ext = filePath.toLowerCase().split('.').pop() || '';
-  const fileName = filePath.split('/').pop() || filePath;
+  const fileName = filePath.split(/[\\/]/).pop() || filePath;
 
   const contentEl = document.getElementById('diagram-content') as HTMLDivElement;
   const loadingEl = document.getElementById('diagram-loading') as HTMLDivElement;
@@ -14138,7 +14138,7 @@ function formatActivityDetails(entry: ActivityEntry): string {
     case 'highlight_cleared':
       return `${d.count} removed`;
     case 'diff_compared':
-      return `${(d.leftFile as string || '').split('/').pop()} vs ${(d.rightFile as string || '').split('/').pop()}`;
+      return `${(d.leftFile as string || '').split(/[\\/]/).pop()} vs ${(d.rightFile as string || '').split(/[\\/]/).pop()}`;
     case 'time_gap_analysis':
       return `${d.gapsFound} gaps (>${d.threshold}s)`;
     case 'analysis_run':