@axhub/genie 0.1.7 → 0.1.9

package/server/gemini-cli.js

@@ -101,11 +101,68 @@ function emitTextChunks(ws, sessionId, chunks) {
   });
 }
 
+function formatGeminiProcessError(code, stderrOutput) {
+  const normalizedStderr = String(stderrOutput || '').trim();
+  if (normalizedStderr) {
+    const apiMessageMatch =
+      normalizedStderr.match(/"message":"([^"]+)"/) ||
+      normalizedStderr.match(/message:\s*"([^"]+)"/i) ||
+      normalizedStderr.match(/ApiError:\s*\{.*?"message":"([^"]+)"/i) ||
+      normalizedStderr.match(/Error when talking to Gemini API[\s\S]*?message":"([^"]+)"/i);
+
+    if (apiMessageMatch?.[1]) {
+      return apiMessageMatch[1];
+    }
+
+    const firstMeaningfulLine = normalizedStderr
+      .split('\n')
+      .map((line) => line.trim())
+      .find((line) => line && !line.startsWith('at '));
+
+    if (firstMeaningfulLine) {
+      return firstMeaningfulLine;
+    }
+
+    return normalizedStderr;
+  }
+
+  return `Gemini CLI exited with code ${code}`;
+}
+
+function extractGeminiEventError(event) {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  const candidates = [
+    event?.error?.message,
+    event?.error?.details,
+    event?.result?.error?.message,
+    event?.result?.error,
+    event?.data?.error?.message,
+    event?.data?.error,
+    event?.message
+  ];
+
+  for (const candidate of candidates) {
+    const normalized = String(candidate || '').trim();
+    if (normalized) {
+      return normalized;
+    }
+  }
+
+  return null;
+}
+
 async function queryGemini(command, options = {}, ws) {
   return new Promise((resolve, reject) => {
     const { sessionId, cwd, projectPath, resume, model, permissionMode } = options;
     let capturedSessionId = sessionId;
     let sentSessionCreated = false;
+    let stderrBuffer = '';
+    let fatalErrorSent = false;
+    let sawSuccessfulTerminalEvent = false;
+    let sawErroredTerminalEvent = false;
 
     const args = ['-y', '@google/gemini-cli'];
 
@@ -142,6 +199,19 @@ async function queryGemini(command, options = {}, ws) {
     activeGeminiProcesses.set(processRegistryKey, geminiProcess);
 
     const finalizeSessionId = () => capturedSessionId || sessionId || null;
+    const emitFatalError = (errorMessage) => {
+      if (fatalErrorSent || !errorMessage) {
+        return;
+      }
+
+      fatalErrorSent = true;
+      ws.send({
+        type: 'claude-error',
+        error: errorMessage,
+        provider: 'gemini',
+        sessionId: finalizeSessionId()
+      });
+    };
 
     const handleJsonEvent = (event) => {
       const incomingSessionId = event?.session_id || event?.sessionId || event?.data?.session_id || event?.data?.sessionId;
@@ -169,6 +239,15 @@ async function queryGemini(command, options = {}, ws) {
 
       const type = event?.type || event?.event || event?.kind;
       if (type === 'result' || type === 'done' || type === 'complete') {
+        const eventStatus = String(event?.status || event?.result?.status || '').trim().toLowerCase();
+        const eventError = extractGeminiEventError(event);
+        if (eventStatus === 'error' || eventError) {
+          sawErroredTerminalEvent = true;
+          emitFatalError(eventError || 'Gemini CLI request failed');
+          return;
+        }
+
+        sawSuccessfulTerminalEvent = true;
         ws.send({
           type: 'claude-response',
           data: { type: 'content_block_stop' },
@@ -204,11 +283,13 @@ async function queryGemini(command, options = {}, ws) {
     });
 
     geminiProcess.stderr.on('data', (data) => {
-      ws.send({
-        type: 'claude-error',
-        error: data.toString(),
-        sessionId: finalizeSessionId()
-      });
+      const chunk = data.toString();
+      stderrBuffer += chunk;
+
+      const normalizedChunk = chunk.trim();
+      if (normalizedChunk) {
+        console.warn('Gemini CLI stderr:', normalizedChunk);
+      }
     });
 
     geminiProcess.on('close', (code) => {
@@ -223,29 +304,35 @@ async function queryGemini(command, options = {}, ws) {
 
       activeGeminiProcesses.delete(processRegistryKey);
 
-      ws.send({
-        type: 'claude-complete',
-        sessionId: finalizeSessionId(),
-        provider: 'gemini',
-        exitCode: code,
-        isNewSession: !sessionId && !!command
-      });
+      if (code === 0 && !sawErroredTerminalEvent) {
+        if (!sawSuccessfulTerminalEvent) {
+          ws.send({
+            type: 'claude-response',
+            data: { type: 'content_block_stop' },
+            provider: 'gemini',
+            sessionId: finalizeSessionId()
+          });
+        }
 
-      if (code === 0) {
+        ws.send({
+          type: 'claude-complete',
+          sessionId: finalizeSessionId(),
+          provider: 'gemini',
+          exitCode: code,
+          isNewSession: !sessionId && !!command
+        });
         resolve();
       } else {
-        reject(new Error(`Gemini CLI exited with code ${code}`));
+        const errorMessage = formatGeminiProcessError(code, stderrBuffer);
+        emitFatalError(errorMessage);
+        reject(new Error(errorMessage));
       }
     });
 
     geminiProcess.on('error', (error) => {
       activeGeminiProcesses.delete(processRegistryKey);
 
-      ws.send({
-        type: 'claude-error',
-        error: error.message,
-        sessionId: finalizeSessionId()
-      });
+      emitFatalError(error.message);
 
       reject(error);
     });

package/server/index.js

@@ -73,30 +73,33 @@ import pty from 'node-pty';
 import fetch from 'node-fetch';
 import mime from 'mime-types';
 
-import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, getGeminiSessionMessages } from './projects.js';
-import { queryClaudeSDK, abortClaudeSDKSession, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval } from './claude-sdk.js';
-import { spawnCursor, abortCursorSession, isCursorSessionActive, getActiveCursorSessions } from './cursor-cli.js';
-import { queryCodex, abortCodexSession, isCodexSessionActive, getActiveCodexSessions } from './openai-codex.js';
-import { queryGemini, abortGeminiSession, isGeminiSessionActive, getActiveGeminiSessions } from './gemini-cli.js';
-import { queryOpencode, abortOpencodeSession, isOpencodeSessionActive, getActiveOpencodeSessions } from './opencode-cli.js';
+import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, clearProviderSessionLookupCaches, getGeminiSessionMessages } from './projects.js';
+import { queryClaudeSDK, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval } from './claude-sdk.js';
+import { queryCodex, isCodexSessionActive, getActiveCodexSessions } from './openai-codex.js';
+import { queryGemini, isGeminiSessionActive, getActiveGeminiSessions } from './gemini-cli.js';
+import { queryOpencode, isOpencodeSessionActive, getActiveOpencodeSessions } from './opencode-cli.js';
 import gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
-import cursorRoutes from './routes/cursor.js';
 import taskmasterRoutes from './routes/taskmaster.js';
 import mcpUtilsRoutes from './routes/mcp-utils.js';
 import commandsRoutes from './routes/commands.js';
 import settingsRoutes from './routes/settings.js';
+import channelsRoutes from './routes/channels.js';
 import agentRoutes from './routes/agent.js';
 import projectsRoutes, { WORKSPACES_ROOT, validateWorkspacePath } from './routes/projects.js';
 import cliAuthRoutes from './routes/cli-auth.js';
 import userRoutes from './routes/user.js';
 import codexRoutes from './routes/codex.js';
 import opencodeRoutes from './routes/opencode.js';
+import sessionCoreRoutes from './routes/session-core.js';
 import { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
 import { initializeDatabase } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
 import { IS_PLATFORM } from './constants/config.js';
+import { getChannelManager } from './channels/index.js';
+import { SessionEventMirrorWriter } from './session-core/runtimeWriter.js';
+import { abortAgentSessionWithWriter } from './session-core/abortSession.js';
 
 // File system watcher for projects folder
 let projectsWatcher = null;
@@ -241,10 +244,26 @@ function broadcastProgress(progress) {
     });
 }
 
-// Setup file system watcher for Claude projects folder using chokidar
+function extractSessionIdFromChangedFile(filePath) {
+    const basename = path.basename(filePath || '', path.extname(filePath || ''));
+    if (!basename) {
+        return null;
+    }
+
+    const directMatch = basename.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i);
+    if (directMatch?.[1]) {
+        return directMatch[1];
+    }
+
+    return basename || null;
+}
+
+// Setup file system watcher for project and provider session folders using chokidar
 async function setupProjectsWatcher() {
     const chokidar = (await import('chokidar')).default;
     const claudeProjectsPath = path.join(os.homedir(), '.claude', 'projects');
+    const codexSessionsPath = path.join(os.homedir(), '.codex', 'sessions');
+    const watchRoots = [claudeProjectsPath, codexSessionsPath];
 
     if (projectsWatcher) {
         projectsWatcher.close();
@@ -252,7 +271,7 @@ async function setupProjectsWatcher() {
 
     try {
         // Initialize chokidar watcher with optimized settings
-        projectsWatcher = chokidar.watch(claudeProjectsPath, {
+        projectsWatcher = chokidar.watch(watchRoots, {
             ignored: [
                 '**/node_modules/**',
                 '**/.git/**',
@@ -287,17 +306,26 @@ async function setupProjectsWatcher() {
 
                     // Clear project directory cache when files change
                     clearProjectDirectoryCache();
+                    clearProviderSessionLookupCaches();
 
                     // Get updated projects list
                     const updatedProjects = await getProjects(broadcastProgress);
 
                     // Notify all connected clients about the project changes
+                    const changedProvider = filePath.startsWith(codexSessionsPath)
+                        ? 'codex'
+                        : 'claude';
+                    const changedFileRoot = changedProvider === 'codex'
+                        ? codexSessionsPath
+                        : claudeProjectsPath;
                     const updateMessage = JSON.stringify({
                         type: 'projects_updated',
                         projects: updatedProjects,
                         timestamp: new Date().toISOString(),
                         changeType: eventType,
-                        changedFile: path.relative(claudeProjectsPath, filePath)
+                        changedFile: path.relative(changedFileRoot, filePath),
+                        changedProvider,
+                        changedSessionId: extractSessionIdFromChangedFile(filePath)
                     });
 
                     connectedClients.forEach(client => {
@@ -431,9 +459,6 @@ app.use('/api/git', authenticateToken, gitRoutes);
 // MCP API Routes (protected)
 app.use('/api/mcp', authenticateToken, mcpRoutes);
 
-// Cursor API Routes (protected)
-app.use('/api/cursor', authenticateToken, cursorRoutes);
-
 // TaskMaster API Routes (protected)
 app.use('/api/taskmaster', authenticateToken, taskmasterRoutes);
 
@@ -446,6 +471,9 @@ app.use('/api/commands', authenticateToken, commandsRoutes);
 // Settings API Routes (protected)
 app.use('/api/settings', authenticateToken, settingsRoutes);
 
+// Channels API Routes (protected)
+app.use('/api/channels', authenticateToken, channelsRoutes);
+
 // CLI Authentication API Routes (protected)
 app.use('/api/cli', authenticateToken, cliAuthRoutes);
 
@@ -455,6 +483,7 @@ app.use('/api/user', authenticateToken, userRoutes);
 // Codex API Routes (protected)
 app.use('/api/codex', authenticateToken, codexRoutes);
 app.use('/api/opencode', authenticateToken, opencodeRoutes);
+app.use('/api/session-core', authenticateToken, sessionCoreRoutes);
 
 // Agent API Routes (uses API key authentication)
 app.use('/api/agent', agentRoutes);
@@ -1047,11 +1076,13 @@ function handleChatConnection(ws) {
     connectedClients.add(ws);
 
     // Wrap WebSocket with writer for consistent interface with SSEStreamWriter
-    const writer = new WebSocketWriter(ws);
+    const baseWriter = new WebSocketWriter(ws);
+    const getSessionWriter = (provider = 'claude') => new SessionEventMirrorWriter(baseWriter, provider);
 
     ws.on('message', async (message) => {
+        let data = null;
         try {
-            const data = JSON.parse(message);
+            data = JSON.parse(message);
 
             if (data.type === 'claude-command') {
                 console.log('[DEBUG] User message:', data.command || '[Continue/Resume]');
@@ -1059,62 +1090,34 @@ function handleChatConnection(ws) {
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
 
                 // Use Claude Agents SDK
-                await queryClaudeSDK(data.command, data.options, writer);
-            } else if (data.type === 'cursor-command') {
-                console.log('[DEBUG] Cursor message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.cwd || 'Unknown');
-                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
-                console.log('🤖 Model:', data.options?.model || 'default');
-                await spawnCursor(data.command, data.options, writer);
+                await queryClaudeSDK(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'claude'));
             } else if (data.type === 'codex-command') {
                 console.log('[DEBUG] Codex message:', data.command || '[Continue/Resume]');
                 console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 console.log('🤖 Model:', data.options?.model || 'default');
-                await queryCodex(data.command, data.options, writer);
+                await queryCodex(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'codex'));
             } else if (data.type === 'gemini-command') {
                 console.log('[DEBUG] Gemini message:', data.command || '[Continue/Resume]');
                 console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 console.log('🤖 Model:', data.options?.model || 'default');
-                await queryGemini(data.command, data.options, writer);
+                await queryGemini(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'gemini'));
             } else if (data.type === 'opencode-command') {
                 console.log('[DEBUG] OpenCode message:', data.command || '[Continue/Resume]');
                 console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 console.log('🤖 Model:', data.options?.model || 'default');
-                await queryOpencode(data.command, data.options, writer);
-            } else if (data.type === 'cursor-resume') {
-                // Backward compatibility: treat as cursor-command with resume and no prompt
-                console.log('[DEBUG] Cursor resume session (compat):', data.sessionId);
-                await spawnCursor('', {
-                    sessionId: data.sessionId,
-                    resume: true,
-                    cwd: data.options?.cwd
-                }, writer);
+                await queryOpencode(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'opencode'));
             } else if (data.type === 'abort-session') {
                 console.log('[DEBUG] Abort session request:', data.sessionId);
-                const provider = data.provider || 'claude';
-                let success;
-
-                if (provider === 'cursor') {
-                    success = abortCursorSession(data.sessionId);
-                } else if (provider === 'codex') {
-                    success = abortCodexSession(data.sessionId);
-                } else if (provider === 'gemini') {
-                    success = abortGeminiSession(data.sessionId);
-                } else if (provider === 'opencode') {
-                    success = abortOpencodeSession(data.sessionId);
-                } else {
-                    // Use Claude Agents SDK
-                    success = await abortClaudeSDKSession(data.sessionId);
-                }
-
-                writer.send({
-                    type: 'session-aborted',
-                    sessionId: data.sessionId,
+                const provider = typeof data.provider === 'string' && data.provider.trim()
+                    ? data.provider.trim().toLowerCase()
+                    : 'claude';
+                await abortAgentSessionWithWriter({
                     provider,
-                    success
+                    sessionId: data.sessionId,
+                    writer: getSessionWriter(provider)
                 });
             } else if (data.type === 'claude-permission-response') {
                 // Relay UI approval decisions back into the SDK control flow.
@@ -1128,24 +1131,13 @@ function handleChatConnection(ws) {
                         rememberEntry: data.rememberEntry
                     });
                 }
-            } else if (data.type === 'cursor-abort') {
-                console.log('[DEBUG] Abort Cursor session:', data.sessionId);
-                const success = abortCursorSession(data.sessionId);
-                writer.send({
-                    type: 'session-aborted',
-                    sessionId: data.sessionId,
-                    provider: 'cursor',
-                    success
-                });
             } else if (data.type === 'check-session-status') {
                 // Check if a specific session is currently processing
                 const provider = data.provider || 'claude';
                 const sessionId = data.sessionId;
+                const sessionWriter = getSessionWriter(provider);
                 let isActive;
-
-                if (provider === 'cursor') {
-                    isActive = isCursorSessionActive(sessionId);
-                } else if (provider === 'codex') {
+                if (provider === 'codex') {
                     isActive = isCodexSessionActive(sessionId);
                 } else if (provider === 'gemini') {
                     isActive = isGeminiSessionActive(sessionId);
@@ -1156,7 +1148,7 @@ function handleChatConnection(ws) {
                     isActive = isClaudeSDKSessionActive(sessionId);
                 }
 
-                writer.send({
+                sessionWriter.send({
                     type: 'session-status',
                     sessionId,
                     provider,
@@ -1165,22 +1157,22 @@ function handleChatConnection(ws) {
             } else if (data.type === 'get-active-sessions') {
                 // Get all currently active sessions
                 const activeSessions = {
-                    claude: getActiveClaudeSDKSessions(),
-                    cursor: getActiveCursorSessions(),
-                    codex: getActiveCodexSessions(),
+                    claude: getActiveClaudeSDKSessions(),                    codex: getActiveCodexSessions(),
                     gemini: getActiveGeminiSessions(),
                     opencode: getActiveOpencodeSessions()
                 };
-                writer.send({
+                baseWriter.send({
                     type: 'active-sessions',
                     sessions: activeSessions
                 });
             }
         } catch (error) {
             console.error('[ERROR] Chat WebSocket error:', error.message);
-            writer.send({
+            baseWriter.send({
                 type: 'error',
-                error: error.message
+                error: error.message,
+                provider: typeof data?.type === 'string' ? data.type.replace(/-command$/, '') : undefined,
+                sessionId: data?.sessionId || data?.options?.sessionId || null
             });
         }
     });
@@ -1212,11 +1204,9 @@ function handleShellConnection(ws) {
                 const initialCommand = data.initialCommand;
                 const isPlainShell = data.isPlainShell || (!!initialCommand && !hasSession) || provider === 'plain-shell';
 
-                // Login commands (Claude/Cursor auth) should never reuse cached sessions
+                // Login commands should never reuse cached sessions
                 const isLoginCommand = initialCommand && (
-                    initialCommand.includes('setup-token') ||
-                    initialCommand.includes('cursor-agent login') ||
-                    initialCommand.includes('auth login')
+                    initialCommand.includes('setup-token') ||                    initialCommand.includes('auth login')
                 );
 
                 // Include command hash in session key so different commands get separate sessions
@@ -1275,7 +1265,7 @@ function handleShellConnection(ws) {
                 if (isPlainShell) {
                     welcomeMsg = `\x1b[36mStarting terminal in: ${projectPath}\x1b[0m\r\n`;
                 } else {
-                    const providerName = provider === 'cursor' ? 'Cursor' : provider === 'gemini' ? 'Gemini' : 'Claude';
+                    const providerName = provider === 'codex' ? 'Codex' : provider === 'gemini' ? 'Gemini' : provider === 'opencode' ? 'OpenCode' : 'Claude';
                     welcomeMsg = hasSession ?
                         `\x1b[36mResuming ${providerName} session ${sessionId} in: ${projectPath}\x1b[0m\r\n` :
                         `\x1b[36mStarting new ${providerName} session in: ${projectPath}\x1b[0m\r\n`;
@@ -1296,21 +1286,6 @@ function handleShellConnection(ws) {
                         } else {
                             shellCommand = `cd "${projectPath}" && ${initialCommand}`;
                         }
-                    } else if (provider === 'cursor') {
-                        // Use cursor-agent command
-                        if (os.platform() === 'win32') {
-                            if (hasSession && sessionId) {
-                                shellCommand = `Set-Location -Path "${projectPath}"; cursor-agent --resume="${sessionId}"`;
-                            } else {
-                                shellCommand = `Set-Location -Path "${projectPath}"; cursor-agent`;
-                            }
-                        } else {
-                            if (hasSession && sessionId) {
-                                shellCommand = `cd "${projectPath}" && cursor-agent --resume="${sessionId}"`;
-                            } else {
-                                shellCommand = `cd "${projectPath}" && cursor-agent`;
-                            }
-                        }
                     } else if (provider === 'gemini') {
                         if (os.platform() === 'win32') {
                             if (hasSession && sessionId) {
@@ -1761,18 +1736,6 @@ app.get('/api/projects/:projectName/sessions/:sessionId/token-usage', authentica
     if (!safeSessionId) {
       return res.status(400).json({ error: 'Invalid sessionId' });
     }
-
-    // Handle Cursor sessions - they use SQLite and don't have token usage info
-    if (provider === 'cursor') {
-      return res.json({
-        used: 0,
-        total: 0,
-        breakdown: { input: 0, cacheCreation: 0, cacheRead: 0 },
-        unsupported: true,
-        message: 'Token usage tracking not available for Cursor sessions'
-      });
-    }
-
     // Handle Codex sessions
     if (provider === 'codex') {
       const codexSessionsDir = path.join(homeDir, '.codex', 'sessions');
@@ -2086,16 +2049,31 @@ function clearRuntimeStatusFile() {
 }
 
 function registerShutdownHandlers() {
-    process.on('exit', () => {
+    process.on('exit', async () => {
+        try {
+            await getChannelManager().shutdown();
+        } catch (error) {
+            console.warn('[WARN] Failed to shutdown channel manager on exit:', error.message);
+        }
         clearRuntimeStatusFile();
     });
 
-    process.on('SIGINT', () => {
+    process.on('SIGINT', async () => {
+        try {
+            await getChannelManager().shutdown();
+        } catch (error) {
+            console.warn('[WARN] Failed to shutdown channel manager on SIGINT:', error.message);
+        }
         clearRuntimeStatusFile();
         process.exit(0);
     });
 
-    process.on('SIGTERM', () => {
+    process.on('SIGTERM', async () => {
+        try {
+            await getChannelManager().shutdown();
+        } catch (error) {
+            console.warn('[WARN] Failed to shutdown channel manager on SIGTERM:', error.message);
+        }
         clearRuntimeStatusFile();
         process.exit(0);
     });
@@ -2106,6 +2084,7 @@ async function startServer() {
     try {
         // Initialize authentication database
         await initializeDatabase();
+        await getChannelManager().initialize();
 
         // Check if running in production mode (dist folder exists)
         const distIndexPath = path.join(__dirname, '../dist/index.html');

package/server/load-env.js

@@ -7,18 +7,21 @@ import { dirname } from 'path';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-try {
-  const envPath = path.join(__dirname, '../.env');
-  const envFile = fs.readFileSync(envPath, 'utf8');
-  envFile.split('\n').forEach(line => {
-    const trimmedLine = line.trim();
-    if (trimmedLine && !trimmedLine.startsWith('#')) {
-      const [key, ...valueParts] = trimmedLine.split('=');
-      if (key && valueParts.length > 0 && !process.env[key]) {
-        process.env[key] = valueParts.join('=').trim();
+const envPath = path.join(__dirname, '../.env');
+
+if (fs.existsSync(envPath)) {
+  try {
+    const envFile = fs.readFileSync(envPath, 'utf8');
+    envFile.split('\n').forEach(line => {
+      const trimmedLine = line.trim();
+      if (trimmedLine && !trimmedLine.startsWith('#')) {
+        const [key, ...valueParts] = trimmedLine.split('=');
+        if (key && valueParts.length > 0 && !process.env[key]) {
+          process.env[key] = valueParts.join('=').trim();
+        }
       }
-    }
-  });
-} catch (e) {
-  console.log('No .env file found or error reading it:', e.message);
+    });
+  } catch (error) {
+    console.warn('[WARN] Failed to read .env file:', error.message);
+  }
 }