Prefer system tools over bundled fallbacks to avoid conflicts

On machines with Git and Node.js already installed, the bundled MinGit
and Electron node.exe shim were taking priority, breaking npm/npx and
potentially causing version conflicts.

Now checks for system git, bash, and node at startup. Bundled tools
are only added to PATH when the system equivalents are missing. This
means:
- Developer machines: system Git + Node.js + npm all work normally
- Fresh installs: bundled MinGit + Electron shim kick in automatically

Bump version to 0.2.6.

Co-Authored-By: Claude <noreply@anthropic.com>

Author: zoidbergclawd

backend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "elisa-backend",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "private": true,
   "license": "MIT",
   "type": "module",

backend/src/services/agentRunner.test.ts

@@ -185,9 +185,11 @@ describe('AgentRunner', () => {
     expect(result.summary).toBe('No output');
   });
 
-  it('passes Electron executable config when ELISA_RESOURCES_PATH is set', async () => {
+  it('uses Electron shim when ELECTRON_RUN_AS_NODE is set (no system node)', async () => {
     const origPath = process.env.ELISA_RESOURCES_PATH;
+    const origShim = process.env.ELECTRON_RUN_AS_NODE;
     process.env.ELISA_RESOURCES_PATH = '/fake/resources';
+    process.env.ELECTRON_RUN_AS_NODE = '1';
     try {
       mockQuery.mockReturnValue(asyncIterable(makeResultMessage()) as any);
 
@@ -207,6 +209,37 @@ describe('AgentRunner', () => {
     } finally {
       if (origPath === undefined) delete process.env.ELISA_RESOURCES_PATH;
       else process.env.ELISA_RESOURCES_PATH = origPath;
+      if (origShim === undefined) delete process.env.ELECTRON_RUN_AS_NODE;
+      else process.env.ELECTRON_RUN_AS_NODE = origShim;
+    }
+  });
+
+  it('uses system node when available (no executable override)', async () => {
+    const origPath = process.env.ELISA_RESOURCES_PATH;
+    const origShim = process.env.ELECTRON_RUN_AS_NODE;
+    process.env.ELISA_RESOURCES_PATH = '/fake/resources';
+    delete process.env.ELECTRON_RUN_AS_NODE;
+    try {
+      mockQuery.mockReturnValue(asyncIterable(makeResultMessage()) as any);
+
+      const runner = new AgentRunner();
+      await runner.execute({
+        taskId: 'test-1',
+        prompt: 'hello',
+        systemPrompt: 'you are a bot',
+        onOutput: vi.fn().mockResolvedValue(undefined),
+        workingDir: '/tmp/test',
+      });
+
+      const callArgs = mockQuery.mock.calls[0][0];
+      expect(callArgs.options?.executable).toBeUndefined();
+      expect(callArgs.options?.env).toBeUndefined();
+      expect(typeof callArgs.options?.stderr).toBe('function');
+    } finally {
+      if (origPath === undefined) delete process.env.ELISA_RESOURCES_PATH;
+      else process.env.ELISA_RESOURCES_PATH = origPath;
+      if (origShim === undefined) delete process.env.ELECTRON_RUN_AS_NODE;
+      else process.env.ELECTRON_RUN_AS_NODE = origShim;
     }
   });
 

backend/src/services/agentRunner.ts

@@ -176,14 +176,18 @@ export class AgentRunner {
     abortController?: AbortController,
     allowedTools?: string[],
   ): Promise<AgentResult> {
-    // In Electron production, Node.js may not be installed on the system.
-    // Use the Electron binary itself as the Node.js runtime for spawning cli.js.
+    // In Electron production, capture stderr for diagnostics.
+    // When no system Node.js is available (ELECTRON_RUN_AS_NODE is set by
+    // electron/main.ts), use the Electron binary itself as the runtime.
+    // When system node exists, let the SDK use it (preserves npm/npx).
     const isElectronProd = !!process.env.ELISA_RESOURCES_PATH;
+    const useElectronShim = isElectronProd && process.env.ELECTRON_RUN_AS_NODE === '1';
     const stderrChunks: string[] = [];
     const electronExecConfig = isElectronProd
       ? {
-          executable: process.execPath,
-          env: { ...process.env, ELECTRON_RUN_AS_NODE: '1' },
+          ...(useElectronShim
+            ? { executable: process.execPath, env: { ...process.env } }
+            : {}),
           stderr: (data: string) => { stderrChunks.push(data); },
         }
       : {};

electron/main.ts

@@ -183,40 +183,58 @@ async function startBackend(): Promise<void> {
   // Production: tell the backend where packaged resources live
   process.env.ELISA_RESOURCES_PATH = process.resourcesPath;
 
-  // MinGit: set up bundled Git + bash for Windows so Claude Code CLI works
-  // without a system Git installation.
+  // Set up bundled tool fallbacks on Windows.
+  // Prefer system installations when available; fall back to bundled tools
+  // only when the system doesn't have them. This avoids breaking npm/npx
+  // on developer machines that already have Node.js installed.
   if (process.platform === 'win32') {
     const fs = require('fs') as typeof import('fs');
     const os = require('os') as typeof import('os');
-    const mingitDir = path.join(process.resourcesPath, 'mingit');
-    const bashExe = path.join(mingitDir, 'usr', 'bin', 'bash.exe');
-    if (fs.existsSync(bashExe)) {
-      process.env.CLAUDE_CODE_GIT_BASH_PATH = bashExe;
-      const gitCmd = path.join(mingitDir, 'cmd');
-      const gitUsrBin = path.join(mingitDir, 'usr', 'bin');
-      process.env.PATH = `${gitCmd};${gitUsrBin};${process.env.PATH}`;
+    const { execSync } = require('child_process') as typeof import('child_process');
+
+    const hasCommand = (cmd: string): boolean => {
+      try { execSync(`where ${cmd}`, { stdio: 'ignore' }); return true; } catch { return false; }
+    };
+
+    // Git + bash: use system Git if available, otherwise bundled MinGit
+    if (!hasCommand('git')) {
+      const mingitDir = path.join(process.resourcesPath, 'mingit');
+      const bashExe = path.join(mingitDir, 'usr', 'bin', 'bash.exe');
+      if (fs.existsSync(bashExe)) {
+        const gitCmd = path.join(mingitDir, 'cmd');
+        const gitUsrBin = path.join(mingitDir, 'usr', 'bin');
+        process.env.PATH = `${process.env.PATH};${gitCmd};${gitUsrBin}`;
+        console.log('[main] Using bundled MinGit (no system git found)');
+      }
     }
 
-    // Create a node.exe shim so agents and test runners can execute JS.
-    // Hardlink Elisa.exe -> node.exe (zero disk cost on NTFS).
-    // ELECTRON_RUN_AS_NODE=1 makes it behave as plain Node.js.
-    const nodeShimDir = path.join(os.tmpdir(), 'elisa-node');
-    const shimNodeExe = path.join(nodeShimDir, 'node.exe');
-    try {
-      fs.mkdirSync(nodeShimDir, { recursive: true });
-      try { fs.unlinkSync(shimNodeExe); } catch { /* may not exist */ }
-      try {
-        fs.linkSync(process.execPath, shimNodeExe);
-      } catch {
-        fs.copyFileSync(process.execPath, shimNodeExe);
+    // Claude Code needs bash.exe. Set CLAUDE_CODE_GIT_BASH_PATH if not
+    // already resolvable (system Git puts it in PATH automatically).
+    if (!hasCommand('bash')) {
+      const mingitBash = path.join(process.resourcesPath, 'mingit', 'usr', 'bin', 'bash.exe');
+      if (fs.existsSync(mingitBash)) {
+        process.env.CLAUDE_CODE_GIT_BASH_PATH = mingitBash;
       }
-      process.env.PATH = `${nodeShimDir};${process.env.PATH}`;
-    } catch (err) {
-      console.error('Failed to create node.exe shim:', err);
     }
 
-    // Let all child processes use the Electron binary as Node.js.
-    process.env.ELECTRON_RUN_AS_NODE = '1';
+    // Node.js: use system node if available, otherwise create Electron shim.
+    if (!hasCommand('node')) {
+      const nodeShimDir = path.join(os.tmpdir(), 'elisa-node');
+      const shimNodeExe = path.join(nodeShimDir, 'node.exe');
+      try {
+        fs.mkdirSync(nodeShimDir, { recursive: true });
+        try { fs.unlinkSync(shimNodeExe); } catch { /* may not exist */ }
+        try { fs.linkSync(process.execPath, shimNodeExe); }
+        catch { fs.copyFileSync(process.execPath, shimNodeExe); }
+        process.env.PATH = `${process.env.PATH};${nodeShimDir}`;
+        // ELECTRON_RUN_AS_NODE makes the Electron binary act as Node.js.
+        // Only set when using the shim; system node doesn't need it.
+        process.env.ELECTRON_RUN_AS_NODE = '1';
+        console.log('[main] Using Electron node.exe shim (no system node found)');
+      } catch (err) {
+        console.error('[main] Failed to create node.exe shim:', err);
+      }
+    }
   }
 
   const backendDist = path.join(process.resourcesPath, 'backend-dist');

frontend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "frontend",
   "private": true,
-  "version": "0.2.5",
+  "version": "0.2.6",
   "license": "MIT",
   "type": "module",
   "scripts": {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "elisa",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "private": true,
   "license": "MIT",
   "author": "Elisa",