claude-simple 0.2.8 → 0.2.10

package/src/agents/sessions.js

@@ -757,8 +757,18 @@ async function loadGrokContext(sessionDir) {
 }
 
 /** Public helper: load usage/context for any agent session. */
-export async function loadSessionUsage(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionUsage(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = (agent || 'claude').toLowerCase();
+  if (a === 'cursor') {
+    const sessions = await scanCursorSessions(cursorHome);
+    if (!sessions.some(s => s.sessionId === sessionId)) return null;
+    return { agent: 'cursor', sessionId, context: await loadCursorContext(sessionId, cursorHome) };
+  }
+  if (a === 'gemini') {
+    const sessions = await scanGeminiSessions(geminiHome);
+    if (!sessions.some(s => s.sessionId === sessionId)) return null;
+    return { agent: 'gemini', sessionId, context: await loadGeminiContext(sessionId, geminiHome) };
+  }
   if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (!dir) return null;
@@ -890,8 +900,198 @@ export async function loadGrokSessionBundle(sessionDir) {
   return { messages, context };
 }
 
+// ─── Gemini / agy ────────────────────────────────────────────────────────────
+
+function geminiUiSessionsRoot(geminiHome) {
+  return path.join(geminiHome || path.join(os.homedir(), '.gemini'), 'claude-simple-ui', 'sessions');
+}
+
+function geminiJournalPath(sessionId, geminiHome) {
+  return path.join(geminiUiSessionsRoot(geminiHome), `${sessionId}.jsonl`);
+}
+
+function geminiPathFromUri(uri) {
+  if (!uri || typeof uri !== 'string') return null;
+  try { return decodeURIComponent(uri.replace(/^file:\/\//, '')); } catch { return null; }
+}
+
+async function readGeminiJournalMeta(filePath) {
+  let meta = null;
+  let firstUser = null;
+  let turnCount = 0;
+  let totalTokens = 0;
+  try {
+    const stream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      if (d.type === 'session_meta') meta = { ...(meta || {}), ...d };
+      if (d.type === 'user' && d.content?.trim()) {
+        turnCount++;
+        if (!firstUser) firstUser = d.content.trim();
+      }
+      if (d.type === 'result' && d.usage) totalTokens += Number(d.usage.total_tokens) || 0;
+    }
+  } catch {}
+  return { meta, firstUser, turnCount, totalTokens };
+}
+
+/** agy keeps public conversation metadata plus a UI-owned readable journal. */
+export async function scanGeminiSessions(geminiHome, filterCwd = null) {
+  const home = geminiHome || path.join(os.homedir(), '.gemini');
+  const records = new Map();
+  const metadataPath = path.join(home, 'antigravity-cli', 'cache', 'conversation_metadata.json');
+  try {
+    const raw = JSON.parse(await fs.readFile(metadataPath, 'utf8'));
+    for (const [sessionId, item] of Object.entries(raw?.conversations || {})) {
+      const summary = item?.summary || {};
+      const cwd = geminiPathFromUri(summary.WorkspaceURIs?.[0]) || null;
+      records.set(sessionId, {
+        sessionId, agent: 'gemini', cwd, configDir: home,
+        display: summary.Title || summary.Preview || sessionId.slice(0, 8),
+        updatedAt: Date.parse(item?.last_modified_time || summary.UpdatedAt || '') || 0,
+        turnCount: Number(summary.NumSteps) || 0,
+        hasMemory: false,
+      });
+    }
+  } catch {}
+  // history.jsonl catches fresh print-mode conversations before metadata cache
+  // catches up, and provides a useful title for older conversations.
+  try {
+    const stream = fsSync.createReadStream(path.join(home, 'antigravity-cli', 'history.jsonl'));
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      const sessionId = d.conversationId;
+      if (!sessionId) continue;
+      const existing = records.get(sessionId) || {
+        sessionId, agent: 'gemini', cwd: d.workspace || null, configDir: home,
+        display: sessionId.slice(0, 8), updatedAt: 0, turnCount: 0, hasMemory: false,
+      };
+      existing.cwd ||= d.workspace || null;
+      existing.display = existing.display === sessionId.slice(0, 8) ? (d.display || existing.display) : existing.display;
+      existing.updatedAt = Math.max(existing.updatedAt || 0, Number(d.timestamp) || 0);
+      if (d.type !== 'slash_command') existing.turnCount = Math.max(existing.turnCount || 0, 1);
+      records.set(sessionId, existing);
+    }
+  } catch {}
+  try {
+    const entries = await fs.readdir(geminiUiSessionsRoot(home), { withFileTypes: true });
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.jsonl')).map(async e => {
+      const filePath = path.join(geminiUiSessionsRoot(home), e.name);
+      const sessionId = e.name.slice(0, -6);
+      const [stat, parsed] = await Promise.all([fs.stat(filePath), readGeminiJournalMeta(filePath)]);
+      const existing = records.get(sessionId) || { sessionId, agent: 'gemini', configDir: home, hasMemory: false };
+      existing.cwd = parsed.meta?.cwd || existing.cwd || null;
+      existing.display = parsed.firstUser || existing.display || sessionId.slice(0, 8);
+      existing.updatedAt = Math.max(existing.updatedAt || 0, stat.mtimeMs);
+      existing.turnCount = parsed.turnCount || existing.turnCount || 0;
+      existing.totalTokens = parsed.totalTokens || existing.totalTokens || 0;
+      existing.journalPath = filePath;
+      records.set(sessionId, existing);
+    }));
+  } catch {}
+  return [...records.values()].filter(s => !filterCwd || s.cwd === filterCwd);
+}
+
+export async function parseGeminiMessages(filePath) {
+  const messages = [];
+  let pendingAssistant = null;
+  const flushAssistant = () => {
+    if (pendingAssistant?.content) messages.push(pendingAssistant);
+    pendingAssistant = null;
+  };
+  try {
+    const stream = fsSync.createReadStream(filePath);
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      let d; try { d = JSON.parse(line); } catch { continue; }
+      if (d.type === 'user' && d.content?.trim()) {
+        flushAssistant();
+        messages.push({ role: 'user', type: 'text', content: d.content.trim(), ts: d.ts });
+      } else if (d.type === 'assistant_delta' && d.data) {
+        if (!pendingAssistant) pendingAssistant = { role: 'assistant', type: 'text', content: '', ts: d.ts };
+        pendingAssistant.content += d.data;
+      } else if (d.type === 'tool') {
+        flushAssistant();
+        messages.push({ role: 'tool', type: 'tool_use', name: d.name || 'tool', input: d.input || {}, ts: d.ts });
+      } else if (d.type === 'result' && d.usage) {
+        flushAssistant();
+        messages.push({ type: 'token_usage', usage: d.usage, ts: d.ts });
+      }
+    }
+  } catch {}
+  flushAssistant();
+  return messages;
+}
+
+async function findGeminiJournal(sessionId, geminiHome) {
+  const file = geminiJournalPath(sessionId, geminiHome);
+  try { await fs.access(file); return file; } catch { return null; }
+}
+
+async function loadGeminiContext(sessionId, geminiHome) {
+  const file = await findGeminiJournal(sessionId, geminiHome);
+  if (!file) return { note: 'This Gemini conversation predates UI journaling; its native transcript is not exposed by agy.' };
+  const messages = await parseGeminiMessages(file);
+  const usages = messages.filter(m => m.type === 'token_usage').map(m => m.usage || {});
+  const total = { input_tokens: 0, output_tokens: 0, reasoning_tokens: 0, cache_read_input_tokens: 0, total_tokens: 0 };
+  for (const u of usages) for (const key of Object.keys(total)) total[key] += Number(u[key]) || 0;
+  return {
+    turnCount: messages.filter(m => m.role === 'user').length,
+    toolCallCount: messages.filter(m => m.type === 'tool_use').length,
+    lastTurn: usages.at(-1) || null,
+    sessionTotals: total,
+  };
+}
+
 // ─── Unified ──────────────────────────────────────────────────────────────────
 
+// ─── Cursor Agent ────────────────────────────────────────────────────────────
+// Cursor's native transcript format is private. Sessions created through this
+// UI have a durable, UI-owned journal at ~/.cursor/claude-simple-ui/sessions.
+function cursorUiSessionsRoot(cursorHome) {
+  return path.join(cursorHome || path.join(os.homedir(), '.cursor'), 'claude-simple-ui', 'sessions');
+}
+
+function cursorJournalPath(sessionId, cursorHome) {
+  return path.join(cursorUiSessionsRoot(cursorHome), `${sessionId}.jsonl`);
+}
+
+async function findCursorJournal(sessionId, cursorHome) {
+  const file = cursorJournalPath(sessionId, cursorHome);
+  try { await fs.access(file); return file; } catch { return null; }
+}
+
+export async function scanCursorSessions(cursorHome, filterCwd = null) {
+  const home = cursorHome || path.join(os.homedir(), '.cursor');
+  const sessions = [];
+  try {
+    const entries = await fs.readdir(cursorUiSessionsRoot(home), { withFileTypes: true });
+    await Promise.all(entries.filter(e => e.isFile() && e.name.endsWith('.jsonl')).map(async e => {
+      const filePath = path.join(cursorUiSessionsRoot(home), e.name);
+      const [stat, parsed] = await Promise.all([fs.stat(filePath), readGeminiJournalMeta(filePath)]);
+      sessions.push({
+        sessionId: e.name.slice(0, -6), agent: 'cursor', cwd: parsed.meta?.cwd || null,
+        configDir: home, display: parsed.firstUser || e.name.slice(0, 8), updatedAt: stat.mtimeMs,
+        turnCount: parsed.turnCount || 0, totalTokens: parsed.totalTokens || 0,
+        hasMemory: false, journalPath: filePath,
+      });
+    }));
+  } catch {}
+  return sessions.filter(s => !filterCwd || s.cwd === filterCwd);
+}
+
+async function loadCursorContext(sessionId, cursorHome) {
+  const file = await findCursorJournal(sessionId, cursorHome);
+  if (!file) return { note: 'This Cursor conversation predates UI journaling; its native transcript is not exposed by cursor-agent.' };
+  const messages = await parseGeminiMessages(file);
+  const usages = messages.filter(m => m.type === 'token_usage').map(m => m.usage || {});
+  const total = { input_tokens: 0, output_tokens: 0, cache_read_input_tokens: 0, cache_write_input_tokens: 0 };
+  for (const u of usages) for (const key of Object.keys(total)) total[key] += Number(u[key]) || 0;
+  return { turnCount: messages.filter(m => m.role === 'user').length, toolCallCount: messages.filter(m => m.type === 'tool_use').length, lastTurn: usages.at(-1) || null, sessionTotals: total };
+}
+
 /** Normalize cwd so /private/tmp and /tmp (etc.) group together on macOS. */
 export function normalizeCwd(cwd) {
   if (!cwd) return null;
@@ -924,15 +1124,18 @@ function publicSession(s) {
     // keep for deep search only when needed — not sent if stripped below
     _filePath: s.filePath || null,
     _sessionDir: s.sessionDir || null,
+    _journalPath: s.journalPath || null,
   };
 }
 
-export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, filterCwd, agents }) {
-  const want = new Set(agents || ['claude', 'codex', 'grok']);
+export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome, filterCwd, agents }) {
+  const want = new Set(agents || ['claude', 'codex', 'grok', 'gemini', 'cursor']);
   const tasks = [];
   if (want.has('claude')) tasks.push(scanClaudeSessions(claudeConfigDirs, filterCwd));
   if (want.has('codex'))  tasks.push(scanCodexSessions(codexHome, filterCwd));
   if (want.has('grok'))   tasks.push(scanGrokSessions(grokHome, filterCwd));
+  if (want.has('gemini')) tasks.push(scanGeminiSessions(geminiHome, filterCwd));
+  if (want.has('cursor')) tasks.push(scanCursorSessions(cursorHome, filterCwd));
 
   const results = await Promise.all(tasks);
   const seen = new Set();
@@ -949,7 +1152,7 @@ export async function scanAllSessions({ claudeConfigDirs, codexHome, grokHome, f
 
 /** Strip internal-only fields before sending to clients. */
 export function toClientSession(s) {
-  const { _filePath, _sessionDir, ...rest } = s;
+  const { _filePath, _sessionDir, _journalPath, ...rest } = s;
   return rest;
 }
 
@@ -1060,6 +1263,14 @@ async function peekSessionText(s, query) {
         },
       });
     }
+    if (s.agent === 'gemini') {
+      const file = s._journalPath || await findGeminiJournal(s.sessionId, s.configDir);
+      if (!file) return null;
+      return await scanFileForQuery(file, query, {
+        maxLines: 160,
+        extract: d => (d.type === 'user' ? d.content : d.type === 'assistant_delta' ? d.data : null),
+      });
+    }
     // claude
     const file = await findClaudeSessionFile(s.sessionId, null);
     // findClaudeSessionFile needs config dirs — skip if we don't have path
@@ -1165,8 +1376,25 @@ export function groupByProject(sessions) {
  * Load session history. Returns { messages, context } or null.
  * `context` carries window / token usage when the agent exposes it (Grok signals.json).
  */
-export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = agent || 'claude';
+  if (a === 'cursor') {
+    const file = await findCursorJournal(sessionId, cursorHome);
+    if (!file) return null;
+    return { messages: await parseGeminiMessages(file), context: await loadCursorContext(sessionId, cursorHome), agent: 'cursor' };
+  }
+  if (a === 'gemini') {
+    const file = await findGeminiJournal(sessionId, geminiHome);
+    if (!file) {
+      const native = (await scanGeminiSessions(geminiHome)).some(s => s.sessionId === sessionId);
+      if (!native) return null;
+      // agy's native transcript is a private protobuf SQLite format. The
+      // conversation can still be resumed normally; UI-created turns gain a
+      // readable journal from that point onward.
+      return { messages: [], context: await loadGeminiContext(sessionId, geminiHome), agent: 'gemini' };
+    }
+    return { messages: await parseGeminiMessages(file), context: await loadGeminiContext(sessionId, geminiHome), agent: 'gemini' };
+  }
   if (a === 'codex') {
     const file = await findCodexSessionFile(sessionId, codexHome);
     if (!file) return null;
@@ -1183,7 +1411,8 @@ export async function loadSessionMessages(sessionId, agent, { claudeConfigDirs,
   return { messages: await parseClaudeMessages(file), context: null, agent: 'claude' };
 }
 
-export async function loadSessionMemory(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function loadSessionMemory(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
+  if (agent === 'gemini' || agent === 'cursor') return { agent, files: [] };
   if (agent === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (!dir) return null;
@@ -1248,6 +1477,7 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
   const id = String(fileId || '').replaceAll('\\', '/');
   if (!id || id.startsWith('/') || id.split('/').some(p => p === '..' || !p)) return null;
   let root;
+  if (agent === 'gemini' || agent === 'cursor') return null;
   if (agent === 'codex') root = path.join(opts.codexHome || path.join(os.homedir(), '.codex'), 'memories');
   else if (agent === 'grok') {
     const dir = await findGrokSessionDir(sessionId, opts.grokHome);
@@ -1272,10 +1502,10 @@ export async function readSessionMemoryFile(sessionId, agent, fileId, opts) {
 }
 
 /** Return bounded raw JSONL for a particular agent session, for Meta Agent analysis. */
-export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }, { offset = 0, maxLines = 500 } = {}) {
+export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset = 0, maxLines = 500 } = {}) {
   if (!agent) {
-    for (const candidate of ['claude', 'codex', 'grok']) {
-      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome }, { offset, maxLines });
+    for (const candidate of ['claude', 'codex', 'grok', 'gemini', 'cursor']) {
+      const found = await loadSessionJsonl(sessionId, candidate, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }, { offset, maxLines });
       if (found) return found;
     }
     return null;
@@ -1283,6 +1513,8 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   const a = (agent || 'claude').toLowerCase();
   let file;
   if (a === 'codex') file = await findCodexSessionFile(sessionId, codexHome);
+  else if (a === 'cursor') file = await findCursorJournal(sessionId, cursorHome);
+  else if (a === 'gemini') file = await findGeminiJournal(sessionId, geminiHome);
   else if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     file = dir ? path.join(dir, 'chat_history.jsonl') : null;
@@ -1304,11 +1536,20 @@ export async function loadSessionJsonl(sessionId, agent, { claudeConfigDirs, cod
   return { agent: a, fileName: path.basename(file), offset: start, lines, nextOffset: start + lines.length, truncated: hasMore, size: stat?.size || 0 };
 }
 
-export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   const a = (agent || 'claude').toLowerCase();
   let cwd = null;
   let display = null;
-  if (a === 'grok') {
+  if (a === 'cursor') {
+    const found = (await scanCursorSessions(cursorHome)).find(s => s.sessionId === sessionId);
+    cwd = found?.cwd || null;
+    display = found?.display || null;
+  } else if (a === 'gemini') {
+    const sessions = await scanGeminiSessions(geminiHome);
+    const found = sessions.find(s => s.sessionId === sessionId);
+    cwd = found?.cwd || null;
+    display = found?.display || null;
+  } else if (a === 'grok') {
     const dir = await findGrokSessionDir(sessionId, grokHome);
     if (dir) {
       try {
@@ -1339,13 +1580,13 @@ export async function getSessionMeta(sessionId, agent, { claudeConfigDirs, codex
   return { cwd, display };
 }
 
-export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome }) {
+export async function convertSession(sourceSessionId, sourceAgent, targetAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome }) {
   // 1. Get meta and messages from source session
-  const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome });
+  const meta = await getSessionMeta(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const cwd = meta.cwd || null;
   const display = meta.display || 'Converted Session';
   
-  const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome });
+  const bundle = await loadSessionMessages(sourceSessionId, sourceAgent, { claudeConfigDirs, codexHome, grokHome, geminiHome, cursorHome });
   const messages = bundle.messages || [];
 
   // 2. Generate target session ID
@@ -1353,6 +1594,9 @@ export async function convertSession(sourceSessionId, sourceAgent, targetAgent,
 
   // 3. Serialize messages to the target agent
   const ta = targetAgent.toLowerCase();
+  if (ta === 'gemini' || ta === 'cursor') {
+    throw new Error(`${ta === 'cursor' ? 'Cursor' : 'Gemini'} sessions use native conversation storage and cannot be cloned safely. Start a new session instead.`);
+  }
   
   if (ta === 'claude') {
     const configDir = claudeConfigDirs?.[0] || path.join(os.homedir(), '.claude');

package/src/app.js

@@ -14,6 +14,8 @@ import { fileURLToPath } from 'url';
 import { runClaude } from './agents/claude.js';
 import { runCodex } from './agents/codex.js';
 import { runGrok } from './agents/grok.js';
+import { runGemini } from './agents/gemini.js';
+import { runCursor } from './agents/cursor.js';
 import {
   scanAllSessions,
   loadSessionMessages,
@@ -32,6 +34,7 @@ import { createTextBatcher } from './agents/stream-batch.js';
 import { normalizeCommand, mapAgentEmit } from './runtime/protocol.js';
 import { createOutbox } from './runtime/outbox.js';
 import { resolveApproval, cancelApprovalsForSession } from './runtime/approvals.js';
+import { createMcpHttpHandler, createMcpService } from './mcp.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const rootDir = path.join(__dirname, '..');
 
@@ -44,12 +47,16 @@ const SESSION_META_FILE  = process.env.SESSION_META_FILE  || path.join(rootDir,
 const CLAUDE_CLI_PATH = process.env.CLAUDE_CLI_PATH || 'claude';
 const CODEX_CLI_PATH  = process.env.CODEX_CLI_PATH  || 'codex';
 const GROK_CLI_PATH   = process.env.GROK_CLI_PATH   || 'grok';
+const GEMINI_CLI_PATH = process.env.GEMINI_CLI_PATH || process.env.AGY_PATH || 'agy';
+const CURSOR_AGENT_PATH = process.env.CURSOR_AGENT_PATH || 'cursor-agent';
 const CODEX_HOME = (process.env.CODEX_HOME || path.join(os.homedir(), '.codex')).replace(/^~/, os.homedir());
 const GROK_HOME  = (process.env.GROK_HOME  || path.join(os.homedir(), '.grok')).replace(/^~/, os.homedir());
+const GEMINI_HOME = (process.env.GEMINI_HOME || path.join(os.homedir(), '.gemini')).replace(/^~/, os.homedir());
+const CURSOR_HOME = (process.env.CURSOR_HOME || path.join(os.homedir(), '.cursor')).replace(/^~/, os.homedir());
 const ENABLED_AGENTS = (() => {
-  const raw = (process.env.AGENTS || 'claude,codex,grok')
+  const raw = (process.env.AGENTS || 'claude,codex,grok,gemini,cursor')
     .split(',').map(s => s.trim().toLowerCase()).filter(Boolean);
-  return [...new Set(raw.length ? raw : ['claude', 'codex', 'grok'])];
+  return [...new Set(raw.length ? raw : ['claude', 'codex', 'grok', 'gemini', 'cursor'])];
 })();
 const CLAUDE_CONFIG_DIRS = (() => {
   const dirs = (process.env.CLAUDE_CONFIG_DIRS || '')
@@ -186,6 +193,14 @@ function makeToken(user) {
   return jwt.sign({ userId: user.id, username: user.username }, jwtSecret(), { expiresIn: '7d' });
 }
 
+function makeMcpToken(user, expiresInSeconds) {
+  return jwt.sign(
+    { userId: user.userId ?? user.id, username: user.username, scope: 'mcp', tokenId: crypto.randomUUID() },
+    jwtSecret(),
+    { expiresIn: expiresInSeconds },
+  );
+}
+
 function verifyToken(token) {
   try { return jwt.verify(token, jwtSecret()); }
   catch { return null; }
@@ -306,11 +321,37 @@ async function listSessions(filterCwd = null, agentFilter = null) {
     claudeConfigDirs: CLAUDE_CONFIG_DIRS,
     codexHome: CODEX_HOME,
     grokHome: GROK_HOME,
+    geminiHome: GEMINI_HOME,
+    cursorHome: CURSOR_HOME,
     filterCwd,
     agents,
   });
 }
 
+// The HTTP UI endpoint and MCP both need the same agent-aware lookup rule:
+// prefer the stated agent, then fall back only when no preference was given.
+async function readSessionBundle(sessionId, preferredAgent = null) {
+  const opts = {
+    claudeConfigDirs: CLAUDE_CONFIG_DIRS,
+    codexHome: CODEX_HOME,
+    grokHome: GROK_HOME,
+    geminiHome: GEMINI_HOME,
+    cursorHome: CURSOR_HOME,
+  };
+  const order = preferredAgent
+    ? [preferredAgent]
+    : [...ENABLED_AGENTS];
+  for (const agent of order) {
+    const bundle = await loadSessionMessages(sessionId, agent, opts);
+    if (bundle) {
+      return Array.isArray(bundle)
+        ? { messages: bundle, context: null, agent }
+        : { ...bundle, agent: bundle.agent || agent, messages: bundle.messages || [] };
+    }
+  }
+  return null;
+}
+
 /**
  * Wrap agent emit → map/filter → outbox (delta coalesce + batch frames).
  * Agents may still call send() with UI-shaped events; unknown noise is dropped.
@@ -337,6 +378,10 @@ async function dispatchAgent(agent, command, options, send) {
     await runCodex(command, options, send, { ...ctx, cliPath: CODEX_CLI_PATH });
   } else if (a === 'grok') {
     await runGrok(command, options, send, { ...ctx, cliPath: GROK_CLI_PATH });
+  } else if (a === 'gemini') {
+    await runGemini(command, options, send, { ...ctx, cliPath: GEMINI_CLI_PATH, geminiHome: GEMINI_HOME });
+  } else if (a === 'cursor') {
+    await runCursor(command, options, send, { ...ctx, cliPath: CURSOR_AGENT_PATH, cursorHome: CURSOR_HOME });
   } else {
     await runClaude(command, options, send, { ...ctx, cliPath: CLAUDE_CLI_PATH });
   }
@@ -496,6 +541,55 @@ export function createApp() {
 
   app.use(express.json({ limit: '10mb' }));
 
+  // MCP uses a separate short-lived bearer token. Normal UI JWTs deliberately
+  // cannot call /mcp, so a browser token leaked through a URL cannot become an
+  // agent-control credential.
+  const mcpService = createMcpService({
+    listSessions,
+    readSession: readSessionBundle,
+    dispatchAgent,
+    abortSession,
+    isSessionBusy,
+    enabledAgents: ENABLED_AGENTS,
+    toClientSession,
+  });
+  const authenticateMcp = (req) => {
+    const header = req.headers.authorization || '';
+    const token = /^Bearer\s+(.+)$/i.exec(header)?.[1];
+    if (!token) return false;
+    const claims = verifyToken(token);
+    if (claims?.scope === 'mcp') return true;
+
+    // Optional headless deployment token. It is accepted only with an explicit
+    // expiry, keeping the same expiration guarantee as issued JWTs.
+    const configured = process.env.MCP_TOKEN;
+    const expiresRaw = process.env.MCP_TOKEN_EXPIRES_AT;
+    if (!configured || !expiresRaw || token.length !== configured.length) return false;
+    let expiresAt = Number(expiresRaw);
+    if (!Number.isFinite(expiresAt)) expiresAt = Date.parse(expiresRaw);
+    if (expiresAt > 0 && expiresAt < 10_000_000_000) expiresAt *= 1000;
+    return Number.isFinite(expiresAt) && Date.now() < expiresAt
+      && crypto.timingSafeEqual(Buffer.from(token), Buffer.from(configured));
+  };
+  app.post('/mcp', createMcpHttpHandler({ service: mcpService, authenticate: authenticateMcp }));
+
+  // Issue a scoped credential from an already-authenticated UI/API client.
+  // The raw secret is returned once and never written to the credential store.
+  app.post('/api/mcp/tokens', authMiddleware, (req, res) => {
+    try {
+      const requested = req.body?.expiresInSeconds ?? 86_400;
+      if (!Number.isInteger(requested) || requested < 60 || requested > 2_592_000) {
+        return res.status(400).json({ error: 'expiresInSeconds must be an integer between 60 and 2592000' });
+      }
+      const token = makeMcpToken(req.user, requested);
+      const decoded = jwt.decode(token);
+      res.setHeader('Cache-Control', 'no-store');
+      res.status(201).json({ token, tokenType: 'Bearer', expiresAt: Number(decoded?.exp || 0) * 1000, expiresInSeconds: requested });
+    } catch (e) {
+      res.status(500).json({ error: e.message });
+    }
+  });
+
   const distDir   = path.join(rootDir, 'dist');
   const publicDir = path.join(rootDir, 'public');
   // Only ship the built bundle in production. Local `node server.js` serves
@@ -716,6 +810,10 @@ export function createApp() {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
+        geminiHome: GEMINI_HOME,
+        geminiCliPath: GEMINI_CLI_PATH,
+        cursorHome: CURSOR_HOME,
+        cursorAgentPath: CURSOR_AGENT_PATH,
         agents: ENABLED_AGENTS,
       });
       res.json({
@@ -725,11 +823,15 @@ export function createApp() {
           claude: CLAUDE_CONFIG_DIRS,
           codex: CODEX_HOME,
           grok: GROK_HOME,
+          gemini: GEMINI_HOME,
+          cursor: CURSOR_HOME,
         },
         paths: {
           claude: CLAUDE_CLI_PATH,
           codex: CODEX_CLI_PATH,
           grok: GROK_CLI_PATH,
+          gemini: GEMINI_CLI_PATH,
+          cursor: CURSOR_AGENT_PATH,
         },
       });
     } catch (e) {
@@ -833,8 +935,10 @@ export function createApp() {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
+        geminiHome: GEMINI_HOME,
+        cursorHome: CURSOR_HOME,
       };
-      const order = [...new Set([preferred, ...ENABLED_AGENTS, 'claude', 'codex', 'grok'].filter(Boolean))];
+      const order = [...new Set([preferred, ...ENABLED_AGENTS, 'claude', 'codex', 'grok', 'gemini', 'cursor'].filter(Boolean))];
       let data = null;
       for (const a of order) {
         data = await loadSessionUsage(sessionId, a, opts);
@@ -925,6 +1029,8 @@ export function createApp() {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
+        geminiHome: GEMINI_HOME,
+        cursorHome: CURSOR_HOME,
       };
       // Prefer stated agent; only fall back if not found (avoids scanning all agents every time)
       const order = preferred
@@ -975,11 +1081,13 @@ export function createApp() {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
+        geminiHome: GEMINI_HOME,
+        cursorHome: CURSOR_HOME,
       };
 
       let detectedSourceAgent = sourceAgent;
       if (!detectedSourceAgent) {
-        const order = [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok'])];
+        const order = [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok', 'gemini', 'cursor'])];
         for (const a of order) {
           const bundle = await loadSessionMessages(sessionId, a, opts);
           if (bundle) {
@@ -1009,12 +1117,14 @@ export function createApp() {
         claudeConfigDirs: CLAUDE_CONFIG_DIRS,
         codexHome: CODEX_HOME,
         grokHome: GROK_HOME,
+        geminiHome: GEMINI_HOME,
+        cursorHome: CURSOR_HOME,
       };
       // A selected session already knows its agent. Do not fall back to another
       // agent's account-level memory (especially Codex) when that session has none.
       const order = preferred
         ? [preferred]
-        : [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok'])];
+        : [...new Set([...ENABLED_AGENTS, 'claude', 'codex', 'grok', 'gemini', 'cursor'])];
       let memory = null;
       for (const a of order) {
         memory = await loadSessionMemory(sessionId, a, opts);
@@ -1033,7 +1143,7 @@ export function createApp() {
       const file = typeof req.query.file === 'string' ? req.query.file : '';
       if (!/^[0-9a-f-]{36}$/i.test(sessionId)) return res.status(400).json({ error: 'Invalid session id' });
       const row = await readSessionMemoryFile(sessionId, agent, file, {
-        claudeConfigDirs: CLAUDE_CONFIG_DIRS, codexHome: CODEX_HOME, grokHome: GROK_HOME,
+        claudeConfigDirs: CLAUDE_CONFIG_DIRS, codexHome: CODEX_HOME, grokHome: GROK_HOME, geminiHome: GEMINI_HOME, cursorHome: CURSOR_HOME,
       });
       if (!row) return res.status(404).json({ error: 'Memory file not found' });
       res.setHeader('Cache-Control', 'private, max-age=30');
@@ -1076,6 +1186,8 @@ export function createApp() {
     claudeConfigDirs: () => CLAUDE_CONFIG_DIRS,
     codexHome: () => CODEX_HOME,
     grokHome: () => GROK_HOME,
+    geminiHome: () => GEMINI_HOME,
+    cursorHome: () => CURSOR_HOME,
   });
 
   /** Write SSE event */
@@ -1485,8 +1597,18 @@ export function createApp() {
           }
           agentSend(data);
         };
-        await dispatchAgent(agent, cmd.command || '', options, runSend);
-        runOutbox.flush();
+        try {
+          await dispatchAgent(agent, cmd.command || '', options, runSend);
+        } finally {
+          // `complete` is a UI-facing agent event and is not a reliable
+          // scheduling boundary (an adapter may emit it early or more than
+          // once). The hub advances its Grok FIFO only after dispatchAgent has
+          // actually returned from the ACP request.
+          if (agent === 'grok') {
+            runOutbox.send({ type: 'hub-turn-finished', agent, sessionId: runSessionId });
+          }
+          runOutbox.flush();
+        }
         return;
       }
 
@@ -1656,7 +1778,7 @@ export async function init() {
   await bootstrapEnvUser();
   await syncConfigDirs();
   console.log(`[agents] enabled: ${ENABLED_AGENTS.join(', ')}`);
-  console.log(`[agents] claude=${CLAUDE_CLI_PATH}  codex=${CODEX_CLI_PATH}  grok=${GROK_CLI_PATH}`);
+  console.log(`[agents] claude=${CLAUDE_CLI_PATH}  codex=${CODEX_CLI_PATH}  grok=${GROK_CLI_PATH}  gemini=${GEMINI_CLI_PATH}`);
 }
 
 // (session helpers live in ./agents/sessions.js)