@axhub/genie 0.1.5 → 0.1.7

package/server/gemini-cli.js

@@ -0,0 +1,280 @@
+import { spawn } from 'child_process';
+import crossSpawn from 'cross-spawn';
+
+const spawnFunction = process.platform === 'win32' ? crossSpawn : spawn;
+
+const activeGeminiProcesses = new Map();
+
+function collectTextChunks(payload) {
+  if (!payload) return [];
+  if (typeof payload === 'string') return payload.trim() ? [payload] : [];
+
+  const chunks = [];
+
+  if (Array.isArray(payload)) {
+    payload.forEach(item => {
+      chunks.push(...collectTextChunks(item));
+    });
+    return chunks;
+  }
+
+  if (typeof payload !== 'object') {
+    return chunks;
+  }
+
+  const directKeys = ['text', 'response', 'content', 'message', 'delta'];
+  for (const key of directKeys) {
+    if (payload[key] !== undefined) {
+      chunks.push(...collectTextChunks(payload[key]));
+    }
+  }
+
+  if (Array.isArray(payload.parts)) {
+    payload.parts.forEach(part => {
+      chunks.push(...collectTextChunks(part));
+    });
+  }
+
+  if (payload.data && typeof payload.data === 'object') {
+    chunks.push(...collectTextChunks(payload.data));
+  }
+
+  return chunks;
+}
+
+function getEventRole(event) {
+  return (
+    event?.role ||
+    event?.author ||
+    event?.sender ||
+    event?.message?.role ||
+    event?.data?.role ||
+    event?.content?.role ||
+    null
+  );
+}
+
+function extractAssistantTextChunks(event, command) {
+  const role = String(getEventRole(event) || '').toLowerCase();
+  if (role === 'user') return [];
+
+  const eventType = String(event?.type || event?.event || event?.kind || '').toLowerCase();
+  const hasAssistantPayload = !!(event?.response || event?.candidates || event?.delta || event?.text || event?.content || event?.message);
+  if (eventType.includes('prompt') && !hasAssistantPayload) {
+    return [];
+  }
+
+  const normalizedPrompt = String(command || '').trim();
+  return collectTextChunks(event).filter((text) => {
+    const trimmed = String(text || '').trim();
+    if (!trimmed) return false;
+    if (normalizedPrompt && trimmed === normalizedPrompt) return false;
+    return true;
+  });
+}
+
+function parseGeminiJsonLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return null;
+
+  const payload = trimmed.startsWith('data:') ? trimmed.slice(5).trim() : trimmed;
+  if (!payload) return null;
+
+  return JSON.parse(payload);
+}
+
+function emitTextChunks(ws, sessionId, chunks) {
+  chunks.forEach((text) => {
+    if (!text) return;
+    ws.send({
+      type: 'claude-response',
+      data: {
+        type: 'content_block_delta',
+        delta: {
+          type: 'text_delta',
+          text
+        }
+      },
+      provider: 'gemini',
+      sessionId
+    });
+  });
+}
+
+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;
+
+    const args = ['-y', '@google/gemini-cli'];
+
+    if (sessionId && (resume || !command || !command.trim())) {
+      args.push('--resume', sessionId);
+    }
+
+    if (command && command.trim()) {
+      args.push('--prompt', command);
+      args.push('--output-format', 'stream-json');
+    }
+
+    if (model) {
+      args.push('--model', model);
+    }
+
+    if (permissionMode === 'bypassPermissions' || permissionMode === 'acceptEdits') {
+      args.push('--yolo');
+    }
+
+    const workingDir = cwd || projectPath || process.cwd();
+
+    const geminiProcess = spawnFunction('npx', args, {
+      cwd: workingDir,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        GEMINI_NONINTERACTIVE: '1'
+      }
+    });
+
+    const processKey = capturedSessionId || Date.now().toString();
+    let processRegistryKey = processKey;
+    activeGeminiProcesses.set(processRegistryKey, geminiProcess);
+
+    const finalizeSessionId = () => capturedSessionId || sessionId || null;
+
+    const handleJsonEvent = (event) => {
+      const incomingSessionId = event?.session_id || event?.sessionId || event?.data?.session_id || event?.data?.sessionId;
+      if (incomingSessionId && !capturedSessionId) {
+        capturedSessionId = incomingSessionId;
+        if (ws.setSessionId && typeof ws.setSessionId === 'function') {
+          ws.setSessionId(capturedSessionId);
+        }
+
+        if (processRegistryKey !== capturedSessionId) {
+          activeGeminiProcesses.delete(processRegistryKey);
+          activeGeminiProcesses.set(capturedSessionId, geminiProcess);
+          processRegistryKey = capturedSessionId;
+        }
+
+        if (!sessionId && !sentSessionCreated) {
+          sentSessionCreated = true;
+          ws.send({
+            type: 'session-created',
+            sessionId: capturedSessionId,
+            provider: 'gemini'
+          });
+        }
+      }
+
+      const type = event?.type || event?.event || event?.kind;
+      if (type === 'result' || type === 'done' || type === 'complete') {
+        ws.send({
+          type: 'claude-response',
+          data: { type: 'content_block_stop' },
+          provider: 'gemini',
+          sessionId: finalizeSessionId()
+        });
+
+        ws.send({
+          type: 'gemini-result',
+          data: event,
+          sessionId: finalizeSessionId()
+        });
+        return;
+      }
+
+      const textChunks = extractAssistantTextChunks(event, command);
+      emitTextChunks(ws, finalizeSessionId(), textChunks);
+    };
+
+    let stdoutBuffer = '';
+    geminiProcess.stdout.on('data', (data) => {
+      stdoutBuffer += data.toString();
+      const lines = stdoutBuffer.split('\n');
+      stdoutBuffer = lines.pop() || '';
+
+      for (const line of lines) {
+        try {
+          const event = parseGeminiJsonLine(line);
+          if (!event) continue;
+          handleJsonEvent(event);
+        } catch {}
+      }
+    });
+
+    geminiProcess.stderr.on('data', (data) => {
+      ws.send({
+        type: 'claude-error',
+        error: data.toString(),
+        sessionId: finalizeSessionId()
+      });
+    });
+
+    geminiProcess.on('close', (code) => {
+      if (stdoutBuffer.trim()) {
+        try {
+          const finalEvent = parseGeminiJsonLine(stdoutBuffer);
+          if (finalEvent) {
+            handleJsonEvent(finalEvent);
+          }
+        } catch {}
+      }
+
+      activeGeminiProcesses.delete(processRegistryKey);
+
+      ws.send({
+        type: 'claude-complete',
+        sessionId: finalizeSessionId(),
+        provider: 'gemini',
+        exitCode: code,
+        isNewSession: !sessionId && !!command
+      });
+
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Gemini CLI exited with code ${code}`));
+      }
+    });
+
+    geminiProcess.on('error', (error) => {
+      activeGeminiProcesses.delete(processRegistryKey);
+
+      ws.send({
+        type: 'claude-error',
+        error: error.message,
+        sessionId: finalizeSessionId()
+      });
+
+      reject(error);
+    });
+
+    geminiProcess.stdin.end();
+  });
+}
+
+function abortGeminiSession(sessionId) {
+  const process = activeGeminiProcesses.get(sessionId);
+  if (process) {
+    process.kill('SIGTERM');
+    activeGeminiProcesses.delete(sessionId);
+    return true;
+  }
+  return false;
+}
+
+function isGeminiSessionActive(sessionId) {
+  return activeGeminiProcesses.has(sessionId);
+}
+
+function getActiveGeminiSessions() {
+  return Array.from(activeGeminiProcesses.keys());
+}
+
+export {
+  queryGemini,
+  abortGeminiSession,
+  isGeminiSessionActive,
+  getActiveGeminiSessions
+};

package/server/index.js

@@ -73,10 +73,12 @@ 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 } from './projects.js';
+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 gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
@@ -90,6 +92,7 @@ import projectsRoutes, { WORKSPACES_ROOT, validateWorkspacePath } from './routes
 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 { parseCodexTokenCountInfo } from './utils/codexTokenUsage.js';
 import { initializeDatabase } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
@@ -99,6 +102,10 @@ import { IS_PLATFORM } from './constants/config.js';
 let projectsWatcher = null;
 const connectedClients = new Set();
 let isGetProjectsRunning = false; // Flag to prevent reentrant calls
+const UPDATE_PACKAGE_NAME = process.env.UPDATE_PACKAGE_NAME || packageInfo.id || '@axhub/genie';
+const VERSION_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
+let cachedSystemVersion = null;
+let cachedSystemVersionExpiresAt = 0;
 const RUNTIME_STATUS_PATH = (() => {
     if (process.env.AXHUB_GENIE_STATUS_PATH) {
         return process.env.AXHUB_GENIE_STATUS_PATH;
@@ -107,6 +114,120 @@ const RUNTIME_STATUS_PATH = (() => {
     return path.join(os.homedir(), '.axhub-genie', 'runtime-status.json');
 })();
 
+function getNpmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+
+function compareSemver(v1, v2) {
+    const normalizedV1 = String(v1 || '').replace(/^v/i, '').split('-')[0];
+    const normalizedV2 = String(v2 || '').replace(/^v/i, '').split('-')[0];
+    const parts1 = normalizedV1.split('.').map((part) => Number(part));
+    const parts2 = normalizedV2.split('.').map((part) => Number(part));
+
+    for (let i = 0; i < 3; i += 1) {
+        const a = Number.isFinite(parts1[i]) ? parts1[i] : 0;
+        const b = Number.isFinite(parts2[i]) ? parts2[i] : 0;
+        if (a > b) return 1;
+        if (a < b) return -1;
+    }
+
+    return 0;
+}
+
+function readLatestVersionFromNpmRegistry() {
+    return new Promise((resolve, reject) => {
+        const npmCommand = getNpmCommand();
+        const child = spawn(npmCommand, ['view', UPDATE_PACKAGE_NAME, 'version', 'time', '--json'], {
+            cwd: path.join(__dirname, '..'),
+            env: process.env
+        });
+
+        let output = '';
+        let errorOutput = '';
+
+        child.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+
+        child.stderr.on('data', (data) => {
+            errorOutput += data.toString();
+        });
+
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(errorOutput || `npm view exited with code ${code}`));
+                return;
+            }
+
+            try {
+                const parsed = JSON.parse(output.trim());
+                const latestVersion = parsed?.version;
+                if (!latestVersion) {
+                    reject(new Error('npm view returned no version'));
+                    return;
+                }
+
+                const publishedAt = parsed?.time?.[latestVersion] || parsed?.time?.modified || null;
+                resolve({
+                    latestVersion,
+                    publishedAt
+                });
+            } catch (error) {
+                reject(new Error(`failed to parse npm view output: ${error.message}`));
+            }
+        });
+
+        child.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+
+async function getSystemVersionInfo(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && cachedSystemVersion && now < cachedSystemVersionExpiresAt) {
+        return { ...cachedSystemVersion, cacheHit: true, stale: false };
+    }
+
+    try {
+        const npmInfo = await readLatestVersionFromNpmRegistry();
+        const currentVersion = packageInfo.version;
+        const latestVersion = npmInfo.latestVersion;
+        const updateAvailable = compareSemver(latestVersion, currentVersion) > 0;
+        const fetchedAt = new Date().toISOString();
+        const expiresAt = now + VERSION_CACHE_TTL_MS;
+
+        cachedSystemVersion = {
+            packageName: UPDATE_PACKAGE_NAME,
+            currentVersion,
+            latestVersion,
+            updateAvailable,
+            releaseInfo: {
+                title: `v${latestVersion}`,
+                body: '',
+                htmlUrl: `https://www.npmjs.com/package/${UPDATE_PACKAGE_NAME}`,
+                publishedAt: npmInfo.publishedAt
+            },
+            fetchedAt,
+            expiresAt: new Date(expiresAt).toISOString()
+        };
+        cachedSystemVersionExpiresAt = expiresAt;
+
+        return { ...cachedSystemVersion, cacheHit: false, stale: false };
+    } catch (error) {
+        // Return stale cache when npm registry is temporarily unavailable.
+        if (cachedSystemVersion) {
+            return {
+                ...cachedSystemVersion,
+                cacheHit: true,
+                stale: true,
+                warning: `Using stale cached version data: ${error.message}`
+            };
+        }
+        throw error;
+    }
+}
+
 // Broadcast progress to all connected WebSocket clients
 function broadcastProgress(progress) {
     const message = JSON.stringify({
@@ -333,6 +454,7 @@ app.use('/api/user', authenticateToken, userRoutes);
 
 // Codex API Routes (protected)
 app.use('/api/codex', authenticateToken, codexRoutes);
+app.use('/api/opencode', authenticateToken, opencodeRoutes);
 
 // Agent API Routes (uses API key authentication)
 app.use('/api/agent', agentRoutes);
@@ -360,6 +482,27 @@ app.use(express.static(path.join(__dirname, '../dist'), {
 // /api/config endpoint removed - no longer needed
 // Frontend now uses window.location for WebSocket URLs
 
+// System version check endpoint (npm registry with server-side cache)
+app.get('/api/system/version', authenticateToken, async (req, res) => {
+    try {
+        const forceRefresh = String(req.query.force || '').toLowerCase() === 'true';
+        const versionInfo = await getSystemVersionInfo(forceRefresh);
+
+        res.setHeader('Cache-Control', 'private, max-age=3600, stale-while-revalidate=300');
+        res.json({
+            success: true,
+            ...versionInfo,
+            cacheTtlMs: VERSION_CACHE_TTL_MS
+        });
+    } catch (error) {
+        console.error('System version check error:', error);
+        res.status(500).json({
+            success: false,
+            error: error.message
+        });
+    }
+});
+
 // System update endpoint
 app.post('/api/system/update', authenticateToken, async (req, res) => {
     try {
@@ -368,10 +511,11 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
 
         console.log('Starting system update from directory:', projectRoot);
 
-        // Run the update command
-        const updateCommand = 'git checkout main && git pull && npm install';
+        const npmCommand = getNpmCommand();
+        const updateArgs = ['update', '-g', UPDATE_PACKAGE_NAME];
 
-        const child = spawn('sh', ['-c', updateCommand], {
+        // Run npm global update command
+        const child = spawn(npmCommand, updateArgs, {
             cwd: projectRoot,
             env: process.env
         });
@@ -393,17 +537,21 @@ app.post('/api/system/update', authenticateToken, async (req, res) => {
 
         child.on('close', (code) => {
             if (code === 0) {
+                cachedSystemVersion = null;
+                cachedSystemVersionExpiresAt = 0;
                 res.json({
                     success: true,
                     output: output || 'Update completed successfully',
-                    message: 'Update completed. Please restart the server to apply changes.'
+                    message: 'Update completed. Please restart the server to apply changes.',
+                    command: `${npmCommand} ${updateArgs.join(' ')}`
                 });
             } else {
                 res.status(500).json({
                     success: false,
                     error: 'Update command failed',
                     output: output,
-                    errorOutput: errorOutput
+                    errorOutput: errorOutput,
+                    command: `${npmCommand} ${updateArgs.join(' ')}`
                 });
             }
         });
@@ -469,6 +617,20 @@ app.get('/api/projects/:projectName/sessions/:sessionId/messages', authenticateT
     }
 });
 
+app.get('/api/gemini/sessions/:sessionId/messages', authenticateToken, async (req, res) => {
+    try {
+        const { sessionId } = req.params;
+        const { limit, offset } = req.query;
+
+        const parsedLimit = limit ? parseInt(limit, 10) : null;
+        const parsedOffset = offset ? parseInt(offset, 10) : 0;
+        const result = await getGeminiSessionMessages(sessionId, parsedLimit, parsedOffset);
+        res.json(result);
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
 // Rename project endpoint
 app.put('/api/projects/:projectName/rename', authenticateToken, async (req, res) => {
     try {
@@ -910,6 +1072,18 @@ function handleChatConnection(ws) {
                 console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
                 console.log('🤖 Model:', data.options?.model || 'default');
                 await queryCodex(data.command, data.options, writer);
+            } 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);
+            } 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);
@@ -927,6 +1101,10 @@ function handleChatConnection(ws) {
                     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);
@@ -969,6 +1147,10 @@ function handleChatConnection(ws) {
                     isActive = isCursorSessionActive(sessionId);
                 } else if (provider === 'codex') {
                     isActive = isCodexSessionActive(sessionId);
+                } else if (provider === 'gemini') {
+                    isActive = isGeminiSessionActive(sessionId);
+                } else if (provider === 'opencode') {
+                    isActive = isOpencodeSessionActive(sessionId);
                 } else {
                     // Use Claude Agents SDK
                     isActive = isClaudeSDKSessionActive(sessionId);
@@ -985,7 +1167,9 @@ function handleChatConnection(ws) {
                 const activeSessions = {
                     claude: getActiveClaudeSDKSessions(),
                     cursor: getActiveCursorSessions(),
-                    codex: getActiveCodexSessions()
+                    codex: getActiveCodexSessions(),
+                    gemini: getActiveGeminiSessions(),
+                    opencode: getActiveOpencodeSessions()
                 };
                 writer.send({
                     type: 'active-sessions',
@@ -1091,7 +1275,7 @@ function handleShellConnection(ws) {
                 if (isPlainShell) {
                     welcomeMsg = `\x1b[36mStarting terminal in: ${projectPath}\x1b[0m\r\n`;
                 } else {
-                    const providerName = provider === 'cursor' ? 'Cursor' : 'Claude';
+                    const providerName = provider === 'cursor' ? 'Cursor' : provider === 'gemini' ? 'Gemini' : '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`;
@@ -1127,6 +1311,20 @@ function handleShellConnection(ws) {
                                 shellCommand = `cd "${projectPath}" && cursor-agent`;
                             }
                         }
+                    } else if (provider === 'gemini') {
+                        if (os.platform() === 'win32') {
+                            if (hasSession && sessionId) {
+                                shellCommand = `Set-Location -Path "${projectPath}"; npx -y @google/gemini-cli --resume ${sessionId}`;
+                            } else {
+                                shellCommand = `Set-Location -Path "${projectPath}"; npx -y @google/gemini-cli`;
+                            }
+                        } else {
+                            if (hasSession && sessionId) {
+                                shellCommand = `cd "${projectPath}" && npx -y @google/gemini-cli --resume ${sessionId}`;
+                            } else {
+                                shellCommand = `cd "${projectPath}" && npx -y @google/gemini-cli`;
+                            }
+                        }
                     } else {
                         // Use claude command (default) or initialCommand if provided
                         const command = initialCommand || 'claude';