@axhub/genie 0.2.8 → 0.2.10

package/server/_legacy-providers/gemini-cli.js

@@ -1,368 +0,0 @@
-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();
-  });
-}
-
-function abortGeminiSession(sessionId) {
-  const process = activeGeminiProcesses.get(sessionId);
-  if (process) {
-    process.kill('SIGTERM');
-    activeGeminiProcesses.delete(sessionId);
-    return true;
-  }
-  return false;
-}
-
-function isGeminiSessionActive(sessionId) {
-  return activeGeminiProcesses.has(sessionId);
-}
-
-function getActiveGeminiSessions() {
-  return Array.from(activeGeminiProcesses.keys());
-}
-
-export {
-  queryGemini,
-  abortGeminiSession,
-  isGeminiSessionActive,
-  getActiveGeminiSessions
-};