@axhub/genie 0.1.6 → 0.1.8

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';
@@ -85,20 +87,27 @@ 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 { 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';
 
 // File system watcher for projects folder
 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 +116,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({
@@ -325,6 +448,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);
 
@@ -333,6 +459,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 +487,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 +516,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 +542,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 +622,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 +1077,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 +1106,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 +1152,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 +1172,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 +1280,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 +1316,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';
@@ -1888,16 +2091,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);
     });
@@ -1908,6 +2126,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/openai-codex.js

@@ -140,7 +140,7 @@ function transformCodexEvent(event) {
     case 'thread.started':
       return {
         type: 'thread_started',
-        threadId: event.id
+        threadId: event.thread_id || event.id
       };
 
     case 'error':
@@ -157,6 +157,42 @@ function transformCodexEvent(event) {
   }
 }
 
+/**
+ * Extract thread id from thread.started events (SDK uses thread_id)
+ * @param {object} event
+ * @returns {string|null}
+ */
+function getThreadIdFromEvent(event) {
+  const threadId = event?.thread_id || event?.id;
+  return typeof threadId === 'string' && threadId.trim() ? threadId.trim() : null;
+}
+
+/**
+ * Extract text-bearing item info from Codex item events.
+ * Only agent_message and reasoning currently stream textual deltas.
+ * @param {object} item
+ * @returns {{itemId: string, itemType: string, text: string, isReasoning: boolean}|null}
+ */
+function getTextItemInfo(item) {
+  if (!item || (item.type !== 'agent_message' && item.type !== 'reasoning')) {
+    return null;
+  }
+
+  const itemId = typeof item.id === 'string' && item.id.trim()
+    ? item.id.trim()
+    : null;
+  if (!itemId) {
+    return null;
+  }
+
+  return {
+    itemId,
+    itemType: item.type,
+    text: typeof item.text === 'string' ? item.text : '',
+    isReasoning: item.type === 'reasoning'
+  };
+}
+
 /**
  * Map permission mode to Codex SDK options
  * @param {string} permissionMode - 'default', 'acceptEdits', or 'bypassPermissions'
@@ -178,7 +214,8 @@ function mapPermissionModeToCodexOptions(permissionMode) {
     default:
       return {
         sandboxMode: 'workspace-write',
-        approvalPolicy: 'untrusted'
+        // Keep default mode writable and non-blocking for coding workflows.
+        approvalPolicy: 'never'
       };
   }
 }
@@ -195,7 +232,8 @@ export async function queryCodex(command, options = {}, ws) {
     cwd,
     projectPath,
     model,
-    permissionMode = 'default'
+    permissionMode = 'default',
+    modelReasoningEffort
   } = options;
 
   const workingDirectory = cwd || projectPath || process.cwd();
@@ -205,6 +243,7 @@ export async function queryCodex(command, options = {}, ws) {
   let thread;
   let currentSessionId = sessionId;
   let resolvedSessionIdFromEvent = null;
+  const streamedTextByItemId = new Map();
 
   const syncResolvedSessionId = (broadcastUpdate = false) => {
     const resolvedThreadId = typeof thread?.id === 'string' && thread.id.trim()
@@ -252,7 +291,8 @@ export async function queryCodex(command, options = {}, ws) {
       skipGitRepoCheck: true,
       sandboxMode,
       approvalPolicy,
-      model
+      model,
+      ...(modelReasoningEffort ? { modelReasoningEffort } : {})
     };
 
     // Start or resume thread
@@ -289,8 +329,11 @@ export async function queryCodex(command, options = {}, ws) {
     syncResolvedSessionId(true);
 
     for await (const event of streamedTurn.events) {
-      if (event?.type === 'thread.started' && typeof event.id === 'string' && event.id.trim()) {
-        resolvedSessionIdFromEvent = event.id.trim();
+      if (event?.type === 'thread.started') {
+        const eventThreadId = getThreadIdFromEvent(event);
+        if (eventThreadId) {
+          resolvedSessionIdFromEvent = eventThreadId;
+        }
       }
 
       syncResolvedSessionId(true);
@@ -301,8 +344,61 @@ export async function queryCodex(command, options = {}, ws) {
         break;
       }
 
-      if (event.type === 'item.started' || event.type === 'item.updated') {
-        continue;
+      const isItemEvent = event.type === 'item.started' || event.type === 'item.updated' || event.type === 'item.completed';
+      if (isItemEvent) {
+        const textItemInfo = getTextItemInfo(event.item);
+
+        if (textItemInfo) {
+          const previousText = streamedTextByItemId.get(textItemInfo.itemId) || '';
+          const nextText = textItemInfo.text || '';
+
+          let delta = '';
+          if (nextText.startsWith(previousText)) {
+            delta = nextText.slice(previousText.length);
+          } else if (nextText !== previousText) {
+            // Fallback when text is rewritten rather than appended
+            delta = nextText;
+          }
+
+          streamedTextByItemId.set(textItemInfo.itemId, nextText);
+
+          if (delta) {
+            sendMessage(ws, {
+              type: 'codex-response',
+              data: {
+                type: 'item_delta',
+                itemType: textItemInfo.itemType,
+                itemId: textItemInfo.itemId,
+                isReasoning: textItemInfo.isReasoning,
+                delta
+              },
+              sessionId: currentSessionId
+            });
+          }
+
+          if (event.type === 'item.completed') {
+            sendMessage(ws, {
+              type: 'codex-response',
+              data: {
+                type: 'item_done',
+                itemType: textItemInfo.itemType,
+                itemId: textItemInfo.itemId,
+                isReasoning: textItemInfo.isReasoning,
+                content: nextText
+              },
+              sessionId: currentSessionId
+            });
+            streamedTextByItemId.delete(textItemInfo.itemId);
+          }
+
+          continue;
+        }
+
+        // Non-text items can be noisy during started/updated phases.
+        // Keep existing behavior: emit them when completed.
+        if (event.type !== 'item.completed') {
+          continue;
+        }
       }
 
       const transformed = transformCodexEvent(event);