@axhub/genie 0.2.6 → 0.2.8

package/server/gemini-cli.js

@@ -1,368 +1,29 @@
-import { spawn } from 'child_process';
-import crossSpawn from 'cross-spawn';
-import { resolveWorkingDirectory } from './utils/defaultWorkingDirectory.js';
-
-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
-    });
-  });
-}
-
-function formatGeminiProcessError(code, stderrOutput) {
-  const normalizedStderr = String(stderrOutput || '').trim();
-  if (normalizedStderr) {
-    const apiMessageMatch =
-      normalizedStderr.match(/"message":"([^"]+)"/) ||
-      normalizedStderr.match(/message:\s*"([^"]+)"/i) ||
-      normalizedStderr.match(/ApiError:\s*\{.*?"message":"([^"]+)"/i) ||
-      normalizedStderr.match(/Error when talking to Gemini API[\s\S]*?message":"([^"]+)"/i);
-
-    if (apiMessageMatch?.[1]) {
-      return apiMessageMatch[1];
-    }
-
-    const firstMeaningfulLine = normalizedStderr
-      .split('\n')
-      .map((line) => line.trim())
-      .find((line) => line && !line.startsWith('at '));
-
-    if (firstMeaningfulLine) {
-      return firstMeaningfulLine;
-    }
-
-    return normalizedStderr;
-  }
-
-  return `Gemini CLI exited with code ${code}`;
-}
-
-function extractGeminiEventError(event) {
-  if (!event || typeof event !== 'object') {
-    return null;
-  }
-
-  const candidates = [
-    event?.error?.message,
-    event?.error?.details,
-    event?.result?.error?.message,
-    event?.result?.error,
-    event?.data?.error?.message,
-    event?.data?.error,
-    event?.message
-  ];
-
-  for (const candidate of candidates) {
-    const normalized = String(candidate || '').trim();
-    if (normalized) {
-      return normalized;
-    }
-  }
-
-  return null;
-}
-
-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;
-    let stderrBuffer = '';
-    let fatalErrorSent = false;
-    let sawSuccessfulTerminalEvent = false;
-    let sawErroredTerminalEvent = 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 = resolveWorkingDirectory({ cwd, projectPath });
-
-    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 emitFatalError = (errorMessage) => {
-      if (fatalErrorSent || !errorMessage) {
-        return;
-      }
-
-      fatalErrorSent = true;
-      ws.send({
-        type: 'claude-error',
-        error: errorMessage,
-        provider: 'gemini',
-        sessionId: finalizeSessionId()
-      });
-    };
-
-    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') {
-        const eventStatus = String(event?.status || event?.result?.status || '').trim().toLowerCase();
-        const eventError = extractGeminiEventError(event);
-        if (eventStatus === 'error' || eventError) {
-          sawErroredTerminalEvent = true;
-          emitFatalError(eventError || 'Gemini CLI request failed');
-          return;
-        }
-
-        sawSuccessfulTerminalEvent = true;
-        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) => {
-      const chunk = data.toString();
-      stderrBuffer += chunk;
-
-      const normalizedChunk = chunk.trim();
-      if (normalizedChunk) {
-        console.warn('Gemini CLI stderr:', normalizedChunk);
-      }
-    });
-
-    geminiProcess.on('close', (code) => {
-      if (stdoutBuffer.trim()) {
-        try {
-          const finalEvent = parseGeminiJsonLine(stdoutBuffer);
-          if (finalEvent) {
-            handleJsonEvent(finalEvent);
-          }
-        } catch {}
-      }
-
-      activeGeminiProcesses.delete(processRegistryKey);
-
-      if (code === 0 && !sawErroredTerminalEvent) {
-        if (!sawSuccessfulTerminalEvent) {
-          ws.send({
-            type: 'claude-response',
-            data: { type: 'content_block_stop' },
-            provider: 'gemini',
-            sessionId: finalizeSessionId()
-          });
-        }
-
-        ws.send({
-          type: 'claude-complete',
-          sessionId: finalizeSessionId(),
-          provider: 'gemini',
-          exitCode: code,
-          isNewSession: !sessionId && !!command
-        });
-        resolve();
-      } else {
-        const errorMessage = formatGeminiProcessError(code, stderrBuffer);
-        emitFatalError(errorMessage);
-        reject(new Error(errorMessage));
-      }
-    });
-
-    geminiProcess.on('error', (error) => {
-      activeGeminiProcesses.delete(processRegistryKey);
-
-      emitFatalError(error.message);
-
-      reject(error);
-    });
-
-    geminiProcess.stdin.end();
+import {
+  abortAgentSession,
+  executeAgentPrompt,
+  getActiveAgentSessions,
+  isAgentSessionActive
+} from './acp-runtime/index.js';
+
+export async function queryGemini(command, options = {}, writer) {
+  return executeAgentPrompt({
+    agentKey: 'gemini',
+    command,
+    options: {
+      ...options
+    },
+    writer
   });
 }
 
-function abortGeminiSession(sessionId) {
-  const process = activeGeminiProcesses.get(sessionId);
-  if (process) {
-    process.kill('SIGTERM');
-    activeGeminiProcesses.delete(sessionId);
-    return true;
-  }
-  return false;
+export async function abortGeminiSession(sessionId) {
+  return abortAgentSession('gemini', sessionId);
 }
 
-function isGeminiSessionActive(sessionId) {
-  return activeGeminiProcesses.has(sessionId);
+export function isGeminiSessionActive(sessionId) {
+  return isAgentSessionActive('gemini', sessionId);
 }
 
-function getActiveGeminiSessions() {
-  return Array.from(activeGeminiProcesses.keys());
+export function getActiveGeminiSessions() {
+  return getActiveAgentSessions('gemini');
 }
-
-export {
-  queryGemini,
-  abortGeminiSession,
-  isGeminiSessionActive,
-  getActiveGeminiSessions
-};

package/server/index.js

@@ -97,10 +97,13 @@ import fetch from 'node-fetch';
 import mime from 'mime-types';
 
 import { getProjects, getSessions, getSessionMessages, renameProject, deleteSession, deleteProject, addProjectManually, extractProjectDirectory, clearProjectDirectoryCache, clearProviderSessionLookupCaches, getGeminiSessionMessages } from './projects.js';
-import { queryClaudeSDK, isClaudeSDKSessionActive, getActiveClaudeSDKSessions, resolveToolApproval } from './claude-sdk.js';
-import { queryCodex, isCodexSessionActive, getActiveCodexSessions } from './openai-codex.js';
-import { queryGemini, isGeminiSessionActive, getActiveGeminiSessions } from './gemini-cli.js';
-import { queryOpencode, isOpencodeSessionActive, getActiveOpencodeSessions } from './opencode-cli.js';
+import {
+  executeAgentPrompt,
+  getActiveAgentSessions,
+  isAgentSessionActive,
+  resolveAgentPermission,
+  setAgentSessionMode
+} from './acp-runtime/index.js';
 import gitRoutes from './routes/git.js';
 import authRoutes from './routes/auth.js';
 import mcpRoutes from './routes/mcp.js';
@@ -110,8 +113,20 @@ 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 projectsRoutes, {
+  DEFAULT_WORKSPACES_ROOT,
+  HAS_WORKSPACES_ROOT_RESTRICTION,
+  WORKSPACES_ROOTS,
+  validateWorkspacePath
+} from './routes/projects.js';
+import {
+  UNIX_WORKSPACE_ROOTS,
+  buildWorkspaceRootSuggestions,
+  expandWorkspacePath,
+  shouldUseVirtualWorkspaceRoots
+} from './utils/workspaceRoots.js';
 import cliAuthRoutes, { detectProviderInstallationStatus } from './routes/cli-auth.js';
+import ccConnectRoutes from './routes/cc-connect.js';
 import userRoutes from './routes/user.js';
 import codexRoutes from './routes/codex.js';
 import opencodeRoutes from './routes/opencode.js';
@@ -135,6 +150,7 @@ const UPDATE_PACKAGE_NAME = process.env.UPDATE_PACKAGE_NAME || packageInfo.id ||
 const VERSION_CACHE_TTL_MS = 60 * 60 * 1000; // 1 hour
 let cachedSystemVersion = null;
 let cachedSystemVersionExpiresAt = 0;
+const WINDOWS_DRIVES_ROOT = '__windows_drives__';
 const RUNTIME_STATUS_PATH = (() => {
     if (process.env.AXHUB_GENIE_STATUS_PATH) {
         return process.env.AXHUB_GENIE_STATUS_PATH;
@@ -501,6 +517,7 @@ app.use('/api/channels', authenticateToken, channelsRoutes);
 
 // CLI Authentication API Routes (protected)
 app.use('/api/cli', authenticateToken, cliAuthRoutes);
+app.use('/api/cc-connect', authenticateToken, ccConnectRoutes);
 
 // User API Routes (protected)
 app.use('/api/user', authenticateToken, userRoutes);
@@ -740,16 +757,31 @@ app.post('/api/projects/create', authenticateToken, async (req, res) => {
     }
 });
 
-const expandWorkspacePath = (inputPath) => {
-    if (!inputPath) return inputPath;
-    if (inputPath === '~') {
-        return WORKSPACES_ROOT;
-    }
-    if (inputPath.startsWith('~/') || inputPath.startsWith('~\\')) {
-        return path.join(WORKSPACES_ROOT, inputPath.slice(2));
-    }
-    return inputPath;
-};
+async function listWindowsDrives() {
+    const checks = await Promise.all(
+        'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('').map(async (letter) => {
+            const drivePath = `${letter}:\\`;
+            try {
+                await fsPromises.access(drivePath, fs.constants.R_OK);
+                const stats = await fsPromises.stat(drivePath);
+                if (!stats.isDirectory()) {
+                    return null;
+                }
+
+                return {
+                    path: drivePath,
+                    name: drivePath,
+                    type: 'directory',
+                    isDrive: true
+                };
+            } catch (error) {
+                return null;
+            }
+        })
+    );
+
+    return checks.filter(Boolean);
+}
 
 // Browse filesystem endpoint for project suggestions - uses existing getFileTree
 app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
@@ -757,9 +789,47 @@ app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
         const { path: dirPath } = req.query;
         
         console.log('[API] Browse filesystem request for path:', dirPath);
-        console.log('[API] WORKSPACES_ROOT is:', WORKSPACES_ROOT);
+        console.log('[API] WORKSPACES_ROOTS are:', WORKSPACES_ROOTS.length > 0 ? WORKSPACES_ROOTS : '(unrestricted)');
+
+        if (process.platform === 'win32' && dirPath === WINDOWS_DRIVES_ROOT) {
+            const suggestions = await listWindowsDrives();
+            return res.json({
+                path: WINDOWS_DRIVES_ROOT,
+                displayPath: 'This PC',
+                suggestions,
+                platform: process.platform,
+                virtualRoot: 'windows-drives',
+                hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+                allowedRoots: WORKSPACES_ROOTS
+            });
+        }
+
+        if (shouldUseVirtualWorkspaceRoots({ dirPath })) {
+            const suggestions = buildWorkspaceRootSuggestions({
+                allowedWorkspaceRoots: WORKSPACES_ROOTS,
+                homeDir: DEFAULT_WORKSPACES_ROOT,
+                platform: process.platform
+            }).filter((entry) => {
+                try {
+                    return fs.existsSync(entry.path);
+                } catch (error) {
+                    return false;
+                }
+            });
+
+            return res.json({
+                path: UNIX_WORKSPACE_ROOTS,
+                displayPath: 'Allowed workspace roots',
+                suggestions,
+                platform: process.platform,
+                virtualRoot: 'workspace-roots',
+                hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+                allowedRoots: WORKSPACES_ROOTS
+            });
+        }
+
         // Default to home directory if no path provided
-        const defaultRoot = WORKSPACES_ROOT;
+        const defaultRoot = DEFAULT_WORKSPACES_ROOT;
         let targetPath = dirPath ? expandWorkspacePath(dirPath) : defaultRoot;
         
         // Resolve and normalize the path
@@ -823,7 +893,12 @@ app.get('/api/browse-filesystem', authenticateToken, async (req, res) => {
         
         res.json({
             path: resolvedPath,
-            suggestions: suggestions
+            displayPath: resolvedPath,
+            suggestions: suggestions,
+            platform: process.platform,
+            virtualRoot: null,
+            hasWorkspaceRootRestriction: HAS_WORKSPACES_ROOT_RESTRICTION,
+            allowedRoots: WORKSPACES_ROOTS
         });
         
     } catch (error) {
@@ -1112,31 +1187,24 @@ function handleChatConnection(ws) {
         try {
             data = JSON.parse(message);
 
-            if (data.type === 'claude-command') {
-                console.log('[DEBUG] User message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.projectPath || 'Unknown');
-                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
+            const agentCommandTypes = ['claude-command', 'codex-command', 'gemini-command', 'opencode-command'];
 
-                // Use Claude Agents SDK
-                await queryClaudeSDK(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'claude'));
-            } else if (data.type === 'codex-command') {
-                console.log('[DEBUG] Codex message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
-                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
-                console.log('🤖 Model:', data.options?.model || 'default');
-                await queryCodex(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'codex'));
-            } else if (data.type === 'gemini-command') {
-                console.log('[DEBUG] Gemini message:', data.command || '[Continue/Resume]');
+            if (agentCommandTypes.includes(data.type)) {
+                const agentKey = data.type.replace(/-command$/, '');
+                console.log(`[DEBUG] ${agentKey} 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, new SessionEventMirrorWriter(baseWriter, 'gemini'));
-            } else if (data.type === 'opencode-command') {
-                console.log('[DEBUG] OpenCode message:', data.command || '[Continue/Resume]');
-                console.log('📁 Project:', data.options?.projectPath || data.options?.cwd || 'Unknown');
-                console.log('🔄 Session:', data.options?.sessionId ? 'Resume' : 'New');
-                console.log('🤖 Model:', data.options?.model || 'default');
-                await queryOpencode(data.command, data.options, new SessionEventMirrorWriter(baseWriter, 'opencode'));
+
+                await executeAgentPrompt({
+                    agentKey,
+                    command: data.command,
+                    options: {
+                        ...(data.options || {}),
+                        clientRequestId: data.clientRequestId || data.options?.clientRequestId || null
+                    },
+                    writer: new SessionEventMirrorWriter(baseWriter, agentKey)
+                });
             } else if (data.type === 'abort-session') {
                 console.log('[DEBUG] Abort session request:', data.sessionId);
                 const provider = typeof data.provider === 'string' && data.provider.trim()
@@ -1147,13 +1215,29 @@ function handleChatConnection(ws) {
                     sessionId: data.sessionId,
                     writer: getSessionWriter(provider)
                 });
-            } else if (data.type === 'claude-permission-response') {
-                // Relay UI approval decisions back into the SDK control flow.
-                // This does not persist permissions; it only resolves the in-flight request,
-                // introduced so the SDK can resume once the user clicks Allow/Deny.
+            } else if (data.type === 'set-session-mode') {
+                const provider = typeof data.provider === 'string' && data.provider.trim()
+                    ? data.provider.trim().toLowerCase()
+                    : 'claude';
+                const modeId = String(data.modeId || '').trim();
+                if (!data.sessionId || !modeId) {
+                    throw new Error('set-session-mode requires sessionId and modeId');
+                }
+
+                const changed = await setAgentSessionMode(provider, data.sessionId, modeId, {
+                    writer: getSessionWriter(provider)
+                });
+
+                if (!changed) {
+                    throw new Error(`Unable to set session mode for ${provider}:${data.sessionId}`);
+                }
+            } else if (data.type === 'permission-response' || data.type === 'claude-permission-response') {
                 if (data.requestId) {
-                    resolveToolApproval(data.requestId, {
+                    resolveAgentPermission(data.requestId, {
                         allow: Boolean(data.allow),
+                        optionId: data.optionId,
+                        outcome: data.outcome,
+                        cancelled: data.outcome?.outcome === 'cancelled' || Boolean(data.cancelled),
                         updatedInput: data.updatedInput,
                         message: data.message,
                         rememberEntry: data.rememberEntry
@@ -1164,17 +1248,7 @@ function handleChatConnection(ws) {
                 const provider = data.provider || 'claude';
                 const sessionId = data.sessionId;
                 const sessionWriter = getSessionWriter(provider);
-                let isActive;
-                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);
-                }
+                const isActive = isAgentSessionActive(provider, sessionId);
 
                 sessionWriter.send({
                     type: 'session-status',
@@ -1185,9 +1259,10 @@ function handleChatConnection(ws) {
             } else if (data.type === 'get-active-sessions') {
                 // Get all currently active sessions
                 const activeSessions = {
-                    claude: getActiveClaudeSDKSessions(),                    codex: getActiveCodexSessions(),
-                    gemini: getActiveGeminiSessions(),
-                    opencode: getActiveOpencodeSessions()
+                    claude: getActiveAgentSessions('claude'),
+                    codex: getActiveAgentSessions('codex'),
+                    gemini: getActiveAgentSessions('gemini'),
+                    opencode: getActiveAgentSessions('opencode')
                 };
                 baseWriter.send({
                     type: 'active-sessions',