@axhub/genie 0.1.8 → 0.2.0

package/server/index.js

@@ -41,6 +41,20 @@ function getServiceIdentity() {
 }
 
 // ANSI color codes for terminal output
+async function getHealthProviderInstallationSummary() {
+    const providers = ['claude', 'codex', 'gemini', 'opencode'];
+    const statuses = await Promise.all(providers.map(async (provider) => {
+        try {
+            const result = await detectProviderInstallationStatus(provider);
+            return [provider, !!result?.installed];
+        } catch {
+            return [provider, false];
+        }
+    }));
+
+    return Object.fromEntries(statuses);
+}
+
 const colors = {
     reset: '\x1b[0m',
     bright: '\x1b[1m',
@@ -73,16 +87,14 @@ 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';
@@ -90,15 +102,21 @@ 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 cliAuthRoutes, { detectProviderInstallationStatus } 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 { getConfiguredDefaultProjectPath, resolveWorkingDirectory } from './utils/defaultWorkingDirectory.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';
+import { authenticateExternalWebSocketRequest } from './external-agent/auth.js';
+import { handleExternalAgentWebSocketConnection } from './external-agent/ws.js';
 
 // File system watcher for projects folder
 let projectsWatcher = null;
@@ -243,10 +261,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();
@@ -254,7 +288,7 @@ async function setupProjectsWatcher() {
 
     try {
         // Initialize chokidar watcher with optimized settings
-        projectsWatcher = chokidar.watch(claudeProjectsPath, {
+        projectsWatcher = chokidar.watch(watchRoots, {
             ignored: [
                 '**/node_modules/**',
                 '**/.git/**',
@@ -289,17 +323,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 => {
@@ -344,38 +387,52 @@ const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 // Single WebSocket server that handles both paths
 const wss = new WebSocketServer({
     server,
-    verifyClient: (info) => {
+    verifyClient: (info, done) => {
         console.log('WebSocket connection attempt to:', info.req.url);
 
-        // Platform mode: always allow connection
+        const url = new URL(info.req.url, 'http://localhost');
+        const pathname = url.pathname;
+
+        if (pathname === '/api/agent/ws') {
+            const authResult = authenticateExternalWebSocketRequest(info.req);
+            if (!authResult.ok) {
+                console.log('[WARN] External agent WebSocket authentication failed:', authResult.message);
+                done(false, authResult.statusCode || 401, authResult.message || 'Unauthorized');
+                return;
+            }
+
+            console.log('[OK] External agent WebSocket authenticated');
+            done(true);
+            return;
+        }
+
+        // Platform mode: always allow internal UI WebSocket connections.
         if (IS_PLATFORM) {
             const user = authenticateWebSocket(null); // Will return first user
             if (!user) {
                 console.log('[WARN] Platform mode: No user found in database');
-                return false;
+                done(false, 500, 'Platform mode: No user found in database');
+                return;
             }
             info.req.user = user;
-            console.log('[OK] Platform mode WebSocket authenticated for user:', user.username);
-            return true;
+            console.log('[OK] WebSocket authenticated for user:', user.username);
+            done(true);
+            return;
         }
 
-        // Normal mode: verify token
-        // Extract token from query parameters or headers
-        const url = new URL(info.req.url, 'http://localhost');
         const token = url.searchParams.get('token') ||
             info.req.headers.authorization?.split(' ')[1];
 
-        // Verify token
         const user = authenticateWebSocket(token);
         if (!user) {
             console.log('[WARN] WebSocket authentication failed');
-            return false;
+            done(false, 401, 'Unauthorized');
+            return;
         }
 
-        // Store user info in the request for later use
         info.req.user = user;
         console.log('[OK] WebSocket authenticated for user:', user.username);
-        return true;
+        done(true);
     }
 });
 
@@ -397,10 +454,11 @@ app.use(express.json({
 app.use(express.urlencoded({ limit: '50mb', extended: true }));
 
 // Public health check endpoint (no authentication required)
-app.get('/health', (req, res) => {
+app.get('/health', async (req, res) => {
   const service = getServiceIdentity();
   const environment = resolveRuntimeEnvironment(process.env.NODE_ENV === 'production');
   const port = Number(process.env.PORT || 32123);
+  const providersInstalled = await getHealthProviderInstallationSummary();
 
   res.setHeader('X-App-Identifier', service.id);
   res.setHeader('X-App-Name', service.name);
@@ -414,7 +472,8 @@ app.get('/health', (req, res) => {
     runtime: {
       environment,
       port
-    }
+    },
+    providersInstalled
   });
 });
 
@@ -433,9 +492,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);
 
@@ -460,6 +516,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);
@@ -1012,6 +1069,8 @@ wss.on('connection', (ws, request) => {
         handleShellConnection(ws);
     } else if (pathname === '/ws') {
         handleChatConnection(ws);
+    } else if (pathname === '/api/agent/ws') {
+        handleExternalAgentWebSocketConnection(ws, request);
     } else {
         console.log('[WARN] Unknown WebSocket path:', pathname);
         ws.close();
@@ -1052,11 +1111,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]');
@@ -1064,62 +1125,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.
@@ -1133,24 +1166,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);
@@ -1161,7 +1183,7 @@ function handleChatConnection(ws) {
                     isActive = isClaudeSDKSessionActive(sessionId);
                 }
 
-                writer.send({
+                sessionWriter.send({
                     type: 'session-status',
                     sessionId,
                     provider,
@@ -1170,22 +1192,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
             });
         }
     });
@@ -1210,18 +1232,16 @@ function handleShellConnection(ws) {
             console.log('📨 Shell message received:', data.type);
 
             if (data.type === 'init') {
-                const projectPath = data.projectPath || process.cwd();
+                const projectPath = resolveWorkingDirectory({ projectPath: data.projectPath });
                 const sessionId = data.sessionId;
                 const hasSession = data.hasSession;
                 const provider = data.provider || 'claude';
                 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
@@ -1280,7 +1300,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`;
@@ -1301,21 +1321,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) {
@@ -1766,18 +1771,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');
@@ -2057,6 +2050,7 @@ function writeRuntimeStatusFile(port, isProduction) {
             url: `http://localhost:${port}`,
             mode: isProduction ? 'production-build' : 'development-proxy',
             endpoint,
+            defaultProjectPath: getConfiguredDefaultProjectPath() || null,
             startedAt: new Date().toISOString(),
             statusFile: RUNTIME_STATUS_PATH,
         };

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);
+  }
 }