@ian2018cs/agenthub 0.1.19 → 0.1.21

package/server/index.js

@@ -56,7 +56,7 @@ import skillsRoutes from './routes/skills.js';
 import settingsRoutes from './routes/settings.js';
 import { initializeDatabase, userDb } from './database/db.js';
 import { validateApiKey, authenticateToken, authenticateWebSocket } from './middleware/auth.js';
-import { getUserPaths, initCodexDirectories } from './services/user-directories.js';
+import { getUserPaths, initCodexDirectories, initGeminiDirectories } from './services/user-directories.js';
 import { startUsageScanner } from './services/usage-scanner.js';
 
 // File system watcher for projects folder - per user
@@ -184,6 +184,7 @@ const server = http.createServer(app);
 
 const ptySessionsMap = new Map();
 const codexPtySessionsMap = new Map();
+const geminiPtySessionsMap = new Map();
 const PTY_SESSION_TIMEOUT = 30 * 60 * 1000;
 
 // Single WebSocket server that handles both paths
@@ -602,6 +603,8 @@ wss.on('connection', (ws, request) => {
         handleShellConnection(ws, userData);
     } else if (pathname === '/codex') {
         handleCodexConnection(ws, userData);
+    } else if (pathname === '/gemini') {
+        handleGeminiConnection(ws, userData);
     } else if (pathname === '/ws') {
         handleChatConnection(ws, userData);
     } else {
@@ -1278,6 +1281,232 @@ function handleCodexConnection(ws, userData) {
         console.error('[ERROR] Codex WebSocket error:', error);
     });
 }
+
+function handleGeminiConnection(ws, userData) {
+    console.log('💎 Gemini client connected');
+    const userUuid = userData?.uuid || null;
+    let geminiProcess = null;
+    let ptySessionKey = null;
+
+    ws.on('message', async (message) => {
+        try {
+            const data = JSON.parse(message);
+            console.log('📨 Gemini message received:', data.type);
+
+            if (data.type === 'init') {
+                const projectPath = data.projectPath || process.cwd();
+
+                ptySessionKey = `gemini_${projectPath}_${userUuid || 'default'}`;
+
+                const existingSession = geminiPtySessionsMap.get(ptySessionKey);
+                if (existingSession) {
+                    console.log('♻️  Reconnecting to existing Gemini PTY session:', ptySessionKey);
+                    geminiProcess = existingSession.pty;
+                    clearTimeout(existingSession.timeoutId);
+
+                    ws.send(JSON.stringify({
+                        type: 'output',
+                        data: `\x1b[36m[Reconnected to existing Gemini session]\x1b[0m\r\n`
+                    }));
+
+                    if (existingSession.buffer && existingSession.buffer.length > 0) {
+                        console.log(`📜 Sending ${existingSession.buffer.length} buffered Gemini messages`);
+                        existingSession.buffer.forEach(bufferedData => {
+                            ws.send(JSON.stringify({ type: 'output', data: bufferedData }));
+                        });
+                    }
+
+                    existingSession.ws = ws;
+                    return;
+                }
+
+                console.log('[INFO] Starting Gemini in:', projectPath);
+
+                ws.send(JSON.stringify({
+                    type: 'output',
+                    data: `\x1b[36mStarting Gemini in: ${projectPath}\x1b[0m\r\n`
+                }));
+
+                try {
+                    const shell = os.platform() === 'win32' ? 'powershell.exe' : 'bash';
+                    const shellCommand = os.platform() === 'win32'
+                        ? `Set-Location -Path "${projectPath}"; gemini`
+                        : `cd "${projectPath}" && gemini`;
+                    const shellArgs = os.platform() === 'win32'
+                        ? ['-Command', shellCommand]
+                        : ['-c', shellCommand];
+
+                    const termCols = data.cols || 80;
+                    const termRows = data.rows || 24;
+                    console.log('📐 Gemini terminal dimensions:', termCols, 'x', termRows);
+
+                    // Build environment with per-user isolated GEMINI_CLI_HOME for config isolation
+                    const geminiEnv = {
+                        ...process.env,
+                        TERM: 'xterm-256color',
+                        COLORTERM: 'truecolor',
+                        FORCE_COLOR: '3',
+                        BROWSER: 'echo "OPEN_URL:"'
+                    };
+
+                    if (userUuid) {
+                        const userPaths = getUserPaths(userUuid);
+                        // Set GEMINI_CLI_HOME to per-user directory for complete isolation
+                        geminiEnv.GEMINI_CLI_HOME = userPaths.geminiHomeDir;
+                        console.log('🔐 Set GEMINI_CLI_HOME for Gemini user isolation:', userPaths.geminiHomeDir);
+                    }
+
+                    // Inject API credentials from server environment variables
+                    if (process.env.GEMINI_API_KEY) {
+                        geminiEnv.GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+                    }
+                    if (process.env.GOOGLE_GEMINI_BASE_URL) {
+                        geminiEnv.GOOGLE_GEMINI_BASE_URL = process.env.GOOGLE_GEMINI_BASE_URL;
+                    }
+
+                    // Sync skills before starting gemini (mirrors .claude/skills/ into .gemini/skills/)
+                    if (userUuid) {
+                        try {
+                            await initGeminiDirectories(userUuid);
+                        } catch (err) {
+                            console.error('[WARN] Failed to sync gemini skills:', err.message);
+                        }
+                    }
+
+                    geminiProcess = pty.spawn(shell, shellArgs, {
+                        name: 'xterm-256color',
+                        cols: termCols,
+                        rows: termRows,
+                        cwd: os.homedir(),
+                        env: geminiEnv
+                    });
+
+                    console.log('🟢 Gemini process started with PTY, PID:', geminiProcess.pid);
+
+                    geminiPtySessionsMap.set(ptySessionKey, {
+                        pty: geminiProcess,
+                        ws: ws,
+                        buffer: [],
+                        timeoutId: null,
+                        projectPath
+                    });
+
+                    geminiProcess.onData((rawData) => {
+                        const session = geminiPtySessionsMap.get(ptySessionKey);
+                        if (!session) return;
+
+                        if (session.buffer.length < 5000) {
+                            session.buffer.push(rawData);
+                        } else {
+                            session.buffer.shift();
+                            session.buffer.push(rawData);
+                        }
+
+                        if (session.ws && session.ws.readyState === WebSocket.OPEN) {
+                            let outputData = rawData;
+
+                            // URL detection
+                            const patterns = [
+                                /(?:xdg-open|open|start)\s+(https?:\/\/[^\s\x1b\x07]+)/g,
+                                /OPEN_URL:\s*(https?:\/\/[^\s\x1b\x07]+)/g,
+                                /Opening\s+(https?:\/\/[^\s\x1b\x07]+)/gi,
+                                /Visit:\s*(https?:\/\/[^\s\x1b\x07]+)/gi,
+                            ];
+
+                            patterns.forEach(pattern => {
+                                let match;
+                                while ((match = pattern.exec(rawData)) !== null) {
+                                    const url = match[1];
+                                    session.ws.send(JSON.stringify({ type: 'url_open', url }));
+                                    if (pattern.source.includes('OPEN_URL')) {
+                                        outputData = outputData.replace(match[0], `[INFO] Opening in browser: ${url}`);
+                                    }
+                                }
+                            });
+
+                            session.ws.send(JSON.stringify({ type: 'output', data: outputData }));
+                        }
+                    });
+
+                    geminiProcess.onExit((exitCode) => {
+                        console.log('🔚 Gemini process exited with code:', exitCode.exitCode);
+                        const session = geminiPtySessionsMap.get(ptySessionKey);
+                        if (session && session.ws && session.ws.readyState === WebSocket.OPEN) {
+                            session.ws.send(JSON.stringify({
+                                type: 'output',
+                                data: `\r\n\x1b[33mGemini exited with code ${exitCode.exitCode}${exitCode.signal ? ` (${exitCode.signal})` : ''}\x1b[0m\r\n`
+                            }));
+                        }
+                        if (session && session.timeoutId) {
+                            clearTimeout(session.timeoutId);
+                        }
+                        geminiPtySessionsMap.delete(ptySessionKey);
+                        geminiProcess = null;
+                    });
+
+                } catch (spawnError) {
+                    console.error('[ERROR] Error spawning Gemini process:', spawnError);
+                    ws.send(JSON.stringify({
+                        type: 'output',
+                        data: `\r\n\x1b[31mError starting Gemini: ${spawnError.message}\x1b[0m\r\n`
+                    }));
+                }
+
+            } else if (data.type === 'input') {
+                if (geminiProcess && geminiProcess.write) {
+                    try {
+                        geminiProcess.write(data.data);
+                    } catch (error) {
+                        console.error('Error writing to Gemini process:', error);
+                    }
+                }
+            } else if (data.type === 'resize') {
+                if (geminiProcess && geminiProcess.resize) {
+                    geminiProcess.resize(data.cols, data.rows);
+                }
+            } else if (data.type === 'terminate') {
+                console.log('🛑 Gemini terminate request for session:', ptySessionKey);
+                const session = geminiPtySessionsMap.get(ptySessionKey);
+                if (session) {
+                    if (session.timeoutId) clearTimeout(session.timeoutId);
+                    if (session.pty && session.pty.kill) session.pty.kill();
+                    geminiPtySessionsMap.delete(ptySessionKey);
+                }
+                geminiProcess = null;
+            }
+        } catch (error) {
+            console.error('[ERROR] Gemini WebSocket error:', error.message);
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(JSON.stringify({
+                    type: 'output',
+                    data: `\r\n\x1b[31mError: ${error.message}\x1b[0m\r\n`
+                }));
+            }
+        }
+    });
+
+    ws.on('close', () => {
+        console.log('🔌 Gemini client disconnected');
+        if (ptySessionKey) {
+            const session = geminiPtySessionsMap.get(ptySessionKey);
+            if (session) {
+                console.log('⏳ Gemini PTY session kept alive, will timeout in 30 minutes:', ptySessionKey);
+                session.ws = null;
+                session.timeoutId = setTimeout(() => {
+                    console.log('⏰ Gemini PTY session timeout, killing process:', ptySessionKey);
+                    if (session.pty && session.pty.kill) {
+                        session.pty.kill();
+                    }
+                    geminiPtySessionsMap.delete(ptySessionKey);
+                }, PTY_SESSION_TIMEOUT);
+            }
+        }
+    });
+
+    ws.on('error', (error) => {
+        console.error('[ERROR] Gemini WebSocket error:', error);
+    });
+}
 app.post('/api/transcribe', authenticateToken, async (req, res) => {
     try {
         const multer = (await import('multer')).default;
@@ -1944,6 +2173,22 @@ async function startServer() {
                 console.error('[WARN] Codex migration error:', err.message);
             }
 
+            // Migrate existing users: ensure gemini directories exist
+            try {
+                const allUsers = userDb.getAllUsers();
+                for (const user of allUsers) {
+                    if (!user.uuid) continue;
+                    try {
+                        await initGeminiDirectories(user.uuid);
+                    } catch (err) {
+                        console.error(`[WARN] Failed to init gemini dirs for user ${user.uuid}:`, err.message);
+                    }
+                }
+                console.log(`[INFO] Gemini directory migration complete for ${allUsers.length} user(s)`);
+            } catch (err) {
+                console.error('[WARN] Gemini migration error:', err.message);
+            }
+
             // Projects watcher is now per-user, initialized when user connects via WebSocket
         });
     } catch (error) {

package/server/services/gemini-usage-scanner.js

@@ -0,0 +1,249 @@
+/**
+ * Gemini Usage Scanner Service
+ *
+ * Scans Gemini CLI session files (JSON) for token usage data and records it to the database.
+ * Gemini sessions are stored in:
+ *   {geminiHomeDir}/.gemini/tmp/{projectHash}/chats/session-*.json
+ *
+ * Key differences from Claude/Codex sessions:
+ * - Gemini uses plain JSON files (not JSONL)
+ * - Each file is a full session object with a "messages" array
+ * - Token data is in messages with type === "gemini": { input, output, cached, thoughts, tool, total }
+ * - "thoughts" tokens are bundled with output tokens (same billing rate)
+ * - Pro models have two pricing tiers: ≤200k total tokens and >200k total tokens
+ *   - The scanner selects the appropriate tier based on tokens.total per message
+ * - Deduplication is done via sessionId + message.id
+ */
+
+import { promises as fs } from 'fs';
+import path from 'path';
+import { usageDb, userDb } from '../database/db.js';
+import { calculateCost, normalizeModelName } from './pricing.js';
+import { getUserPaths } from './user-directories.js';
+
+const GEMINI_PRO_LARGE_THRESHOLD = 200000; // tokens above this use the higher pricing tier
+
+/**
+ * Scan all Gemini session files for a user
+ * @param {string} userUuid - User UUID
+ */
+export async function scanUserGeminiSessions(userUuid) {
+  const userPaths = getUserPaths(userUuid);
+  const tmpDir = path.join(userPaths.geminiHomeDir, '.gemini', 'tmp');
+  const scanStatePath = path.join(userPaths.geminiHomeDir, '.gemini-usage-scan-state.json');
+
+  // Check if gemini tmp directory exists
+  try {
+    await fs.access(tmpDir);
+  } catch {
+    // No gemini sessions directory yet
+    return;
+  }
+
+  // Load scan state
+  // scannedMessages: { [sessionId]: string[] } (array of processed message IDs)
+  let scanState = { lastScanTime: null, scannedMessages: {} };
+  try {
+    const stateContent = await fs.readFile(scanStatePath, 'utf8');
+    scanState = JSON.parse(stateContent);
+    if (!scanState.scannedMessages) scanState.scannedMessages = {};
+  } catch {
+    // File doesn't exist or is invalid, start fresh
+  }
+
+  let newRecordsCount = 0;
+
+  // Sessions are organized as tmp/{projectHash}/chats/session-*.json
+  let projectDirs;
+  try {
+    projectDirs = await fs.readdir(tmpDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+
+  for (const projectDir of projectDirs) {
+    if (!projectDir.isDirectory()) continue;
+    const chatsDir = path.join(tmpDir, projectDir.name, 'chats');
+
+    let chatFiles;
+    try {
+      chatFiles = await fs.readdir(chatsDir);
+    } catch {
+      continue;
+    }
+
+    for (const chatFile of chatFiles) {
+      if (!chatFile.startsWith('session-') || !chatFile.endsWith('.json')) continue;
+
+      const sessionPath = path.join(chatsDir, chatFile);
+
+      // Get file stats to check if modified
+      let stats;
+      try {
+        stats = await fs.stat(sessionPath);
+      } catch {
+        continue;
+      }
+      const lastModified = stats.mtime.toISOString();
+
+      // Use file path as session key for state tracking (since sessionId is inside the file)
+      const stateKey = `${projectDir.name}/${chatFile}`;
+      const lastScanned = scanState.scannedMessages[stateKey];
+
+      // If file hasn't changed and we have previously scanned it, skip
+      if (lastScanned && lastScanned.lastModified === lastModified) {
+        continue;
+      }
+
+      // Scan the session file
+      try {
+        const processedIds = new Set(lastScanned?.processedIds || []);
+        const scanResult = await scanGeminiSessionFile(
+          userUuid,
+          sessionPath,
+          processedIds
+        );
+        newRecordsCount += scanResult.recordsAdded;
+
+        // Update scan state
+        scanState.scannedMessages[stateKey] = {
+          lastModified,
+          processedIds: Array.from(scanResult.processedIds),
+          lastScan: new Date().toISOString()
+        };
+      } catch (error) {
+        console.error(`[GeminiUsageScanner] Error scanning session ${chatFile}:`, error.message);
+      }
+    }
+  }
+
+  // Save scan state
+  scanState.lastScanTime = new Date().toISOString();
+  try {
+    await fs.writeFile(scanStatePath, JSON.stringify(scanState, null, 2));
+  } catch (error) {
+    console.error(`[GeminiUsageScanner] Error saving scan state for user ${userUuid}:`, error.message);
+  }
+
+  if (newRecordsCount > 0) {
+    console.log(`[GeminiUsageScanner] User ${userUuid}: added ${newRecordsCount} new Gemini usage records`);
+  }
+}
+
+/**
+ * Scan a single Gemini session JSON file for usage data
+ * @param {string} userUuid - User UUID
+ * @param {string} filePath - Full path to session JSON file
+ * @param {Set<string>} processedIds - Already processed message IDs (for deduplication)
+ * @returns {{ recordsAdded: number, processedIds: Set<string> }}
+ */
+async function scanGeminiSessionFile(userUuid, filePath, processedIds) {
+  const content = await fs.readFile(filePath, 'utf8');
+  let session;
+  try {
+    session = JSON.parse(content);
+  } catch {
+    return { recordsAdded: 0, processedIds };
+  }
+
+  const sessionId = session.sessionId || path.basename(filePath, '.json');
+  const messages = session.messages || [];
+
+  let recordsAdded = 0;
+
+  for (const message of messages) {
+    // Only process gemini-type messages that have token data
+    if (message.type !== 'gemini' || !message.tokens) continue;
+
+    const messageId = message.id;
+    if (!messageId) continue;
+
+    // Skip already processed messages
+    if (processedIds.has(messageId)) continue;
+
+    const tokens = message.tokens;
+    const inputTokens = tokens.input || 0;
+    const cachedTokens = tokens.cached || 0;
+    // thoughts tokens are billed at the same rate as output tokens
+    const outputTokens = (tokens.output || 0) + (tokens.thoughts || 0);
+    const totalTokens = tokens.total || 0;
+
+    // Skip if no meaningful usage
+    if (inputTokens === 0 && outputTokens === 0) {
+      processedIds.add(messageId);
+      continue;
+    }
+
+    const rawModel = message.model || 'gemini-3-pro-preview';
+    let model = normalizeModelName(rawModel);
+
+    // For pro models, apply the higher pricing tier if total tokens exceed threshold
+    // The -large suffix keys are defined in pricing.js exclusively for this purpose
+    if (
+      totalTokens > GEMINI_PRO_LARGE_THRESHOLD &&
+      (model === 'gemini-3.1-pro-preview' || model === 'gemini-3-pro-preview')
+    ) {
+      model = `${model}-large`;
+    }
+
+    const cost = calculateCost({
+      model,
+      inputTokens,
+      outputTokens,
+      cacheReadTokens: cachedTokens,
+      cacheCreationTokens: 0
+    });
+
+    const entryTimestamp = message.timestamp || session.startTime || new Date().toISOString();
+    const entryDate = entryTimestamp.split('T')[0];
+
+    // Insert usage record with source='gemini'
+    usageDb.insertRecord({
+      user_uuid: userUuid,
+      session_id: sessionId,
+      model,
+      raw_model: rawModel,
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      cache_read_tokens: cachedTokens,
+      cache_creation_tokens: 0,
+      cost_usd: cost,
+      source: 'gemini',
+      created_at: entryTimestamp
+    });
+
+    // Update daily summary
+    usageDb.upsertDailySummary({
+      user_uuid: userUuid,
+      date: entryDate,
+      model,
+      total_input_tokens: inputTokens,
+      total_output_tokens: outputTokens,
+      total_cost_usd: cost,
+      session_count: 0,
+      request_count: 1
+    });
+
+    processedIds.add(messageId);
+    recordsAdded++;
+  }
+
+  return { recordsAdded, processedIds };
+}
+
+/**
+ * Manually trigger a Gemini scan (for testing or admin use)
+ */
+export async function triggerGeminiScan() {
+  console.log('[GeminiUsageScanner] Manual Gemini scan triggered');
+  const users = userDb.getAllUsers();
+  for (const user of users) {
+    if (!user.uuid) continue;
+    try {
+      await scanUserGeminiSessions(user.uuid);
+    } catch (error) {
+      console.error(`[GeminiUsageScanner] Error scanning user ${user.uuid}:`, error.message);
+    }
+  }
+  return { success: true, message: 'Gemini scan completed' };
+}

package/server/services/pricing.js

@@ -212,6 +212,45 @@ const PRICING_PER_MILLION = {
     cacheCreate5m: 0,
     cacheCreate1h: 0
   },
+  // ============ Gemini Models (Google Gemini CLI) ============
+  // Pro 系列 ≤200k tokens 档
+  'gemini-3.1-pro-preview': {
+    input: 2.00,
+    output: 12.00,
+    cacheRead: 0.20,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0
+  },
+  'gemini-3-pro-preview': {
+    input: 2.00,
+    output: 12.00,
+    cacheRead: 0.20,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0
+  },
+  // Pro 系列 >200k tokens 档（高价档，仅由 gemini-usage-scanner.js 内部使用）
+  'gemini-3.1-pro-preview-large': {
+    input: 4.00,
+    output: 18.00,
+    cacheRead: 0.40,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0
+  },
+  'gemini-3-pro-preview-large': {
+    input: 4.00,
+    output: 18.00,
+    cacheRead: 0.40,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0
+  },
+  // Flash 系列（单一价格档）
+  'gemini-3-flash-preview': {
+    input: 0.50,
+    output: 3.00,
+    cacheRead: 0.05,
+    cacheCreate5m: 0,
+    cacheCreate1h: 0
+  },
   // ============ Aliases ============
   // Aliases for simplified model names (pointing to latest versions)
   'sonnet': {
@@ -284,6 +323,13 @@ function normalizeModelName(model) {
     return 'gpt-5-codex'; // gpt-5-codex 或未知 codex 变体
   }
 
+  // Check for Gemini model patterns (Google Gemini CLI models)
+  if (modelLower.includes('gemini')) {
+    if (modelLower.includes('flash')) return 'gemini-3-flash-preview';
+    if (modelLower.includes('3.1') || modelLower.includes('3-1')) return 'gemini-3.1-pro-preview';
+    return 'gemini-3-pro-preview';
+  }
+
   // Check for GPT-5 model patterns (OpenAI)
   if (modelLower.includes('gpt-5') || modelLower.startsWith('gpt5')) {
     if (modelLower.includes('nano')) return 'gpt-5-nano';

package/server/services/usage-scanner.js

@@ -17,6 +17,7 @@ import { usageDb, userDb } from '../database/db.js';
 import { calculateCost, normalizeModelName } from './pricing.js';
 import { DATA_DIR, getUserPaths } from './user-directories.js';
 import { scanUserCodexSessions } from './codex-usage-scanner.js';
+import { scanUserGeminiSessions } from './gemini-usage-scanner.js';
 
 // Scan interval: 5 minutes
 const SCAN_INTERVAL_MS = 5 * 60 * 1000;
@@ -88,6 +89,12 @@ async function runScan() {
       } catch (error) {
         console.error(`[UsageScanner] Error scanning Codex sessions for user ${user.uuid}:`, error.message);
       }
+
+      try {
+        await scanUserGeminiSessions(user.uuid);
+      } catch (error) {
+        console.error(`[UsageScanner] Error scanning Gemini sessions for user ${user.uuid}:`, error.message);
+      }
     }
 
     // Cleanup old records