@axhub/genie 0.2.5 → 0.2.7

package/server/cli.js

@@ -740,6 +740,8 @@ function showStatus(options = {}) {
 
 // Show help
 function showHelp() {
+    const defaultProjectUrl = 'https://github.com/lintendo/AI-Web-UI';
+    const defaultIssuesUrl = `${defaultProjectUrl}/issues`;
     console.log(`
 ╔═══════════════════════════════════════════════════════════════╗
 ║              Axhub Genie - Command Line Tool               ║
@@ -805,10 +807,10 @@ Environment Variables:
   AXHUB_GENIE_NO_OPEN  Set to true to disable auto-opening the homepage
 
 Documentation:
-  ${packageJson.homepage || 'https://github.com/siteboon/claudecodeui'}
+  ${packageJson.homepage || defaultProjectUrl}
 
 Report Issues:
-  ${packageJson.bugs?.url || 'https://github.com/siteboon/claudecodeui/issues'}
+  ${packageJson.bugs?.url || defaultIssuesUrl}
 `);
 }
 
@@ -817,6 +819,10 @@ function showVersion() {
     console.log(`${packageJson.version}`);
 }
 
+function getManualUpdateCommand(packageName = packageJson.name || '@axhub/genie') {
+    return `npm install -g ${packageName}@latest`;
+}
+
 // Compare semver versions, returns true if v1 > v2
 function isNewerVersion(v1, v2) {
     const parts1 = v1.split('.').map(Number);
@@ -838,7 +844,7 @@ async function checkForUpdates(silent = false) {
 
         if (isNewerVersion(latestVersion, currentVersion)) {
             console.log(`\n${c.warn('[UPDATE]')} New version available: ${c.bright(latestVersion)} (current: ${currentVersion})`);
-            console.log(`         Run ${c.bright('axhub-genie update')} to update\n`);
+            console.log(`         Run ${c.bright(getManualUpdateCommand(packageName))} to update\n`);
             return { hasUpdate: true, latestVersion, currentVersion };
         } else if (!silent) {
             console.log(`${c.ok('[OK]')} You are on the latest version (${currentVersion})`);
@@ -867,11 +873,11 @@ async function updatePackage() {
         }
 
         console.log(`${c.info('[INFO]')} Updating from ${currentVersion} to ${latestVersion}...`);
-        execSync(`npm update -g ${packageName}`, { stdio: 'inherit' });
+        execSync(getManualUpdateCommand(packageName), { stdio: 'inherit' });
         console.log(`${c.ok('[OK]')} Update complete! Restart axhub-genie to use the new version.`);
     } catch (e) {
         console.error(`${c.error('[ERROR]')} Update failed: ${e.message}`);
-        console.log(`${c.tip('[TIP]')} Try running manually: npm update -g ${packageJson.name || '@axhub/genie'}`);
+        console.log(`${c.tip('[TIP]')} Try running manually: ${getManualUpdateCommand()}`);
     }
 }
 

package/server/external-agent/service.js

@@ -1,10 +1,12 @@
 import { promises as fs } from 'fs';
 
 import { addProjectManually } from '../projects.js';
-import { queryClaudeSDK } from '../claude-sdk.js';
-import { queryCodex } from '../openai-codex.js';
-import { queryGemini } from '../gemini-cli.js';
-import { queryOpencode } from '../opencode-cli.js';
+import {
+  applyConversationEventToTimelineMessages,
+  CONVERSATION_EVENT_KINDS
+} from '../../shared/conversationEvents.js';
+import { executeAgentPrompt } from '../acp-runtime/index.js';
+import { detectProviderInstallationStatus } from '../routes/cli-auth.js';
 import {
   buildAgentCallbackPayload,
   createAgentCallbackEventId,
@@ -15,7 +17,6 @@ import {
 } from '../utils/agentCallback.js';
 import { normalizeExternalImages } from '../utils/agentImages.js';
 import { resolveWorkingDirectory } from '../utils/defaultWorkingDirectory.js';
-import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
 
 export const SUPPORTED_EXTERNAL_AGENT_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
 
@@ -38,6 +39,29 @@ function getDeprecatedGitHubFields(body) {
   return deprecatedFields.filter((field) => body[field] !== undefined);
 }
 
+async function ensureProviderInstalled(provider) {
+  const status = await detectProviderInstallationStatus(provider);
+  if (status?.installed) {
+    return status;
+  }
+
+  const installHint = typeof status?.installHint === 'string' && status.installHint.trim()
+    ? status.installHint.trim()
+    : null;
+  const reason = typeof status?.reason === 'string' && status.reason.trim()
+    ? status.reason.trim()
+    : null;
+
+  const messageParts = [`Provider "${provider}" is not installed.`];
+  if (installHint) {
+    messageParts.push(installHint);
+  } else if (reason) {
+    messageParts.push(reason);
+  }
+
+  throw createRequestError(messageParts.join(' '), 400);
+}
+
 export function buildSessionNavigation(sessionId) {
   const normalizedSessionId = typeof sessionId === 'string' && sessionId.trim() ? sessionId.trim() : null;
   const sessionPath = normalizedSessionId ? `/session/${normalizedSessionId}` : null;
@@ -250,7 +274,7 @@ function extractTerminalErrorMessage(payload) {
 export class CallbackCaptureWriter {
   constructor() {
     this.sessionId = null;
-    this.assistantMessages = [];
+    this.timelineMessages = [];
     this.tokenSummary = createEmptyTokenSummary();
     this.terminalState = null;
     this.terminalErrorMessage = null;
@@ -279,24 +303,34 @@ export class CallbackCaptureWriter {
       };
     }
 
-    if (payload.type === 'claude-response' && payload.data?.type === 'assistant') {
-      this.assistantMessages.push(payload.data);
-    }
+    if (payload.type === 'conversation-event' && payload.event) {
+      this.timelineMessages = applyConversationEventToTimelineMessages(
+        this.timelineMessages,
+        payload.event,
+        payload.event.provider || 'claude'
+      );
+
+      if (payload.event.kind === CONVERSATION_EVENT_KINDS.ERROR) {
+        this.terminalState = 'errored';
+        this.terminalErrorMessage = payload.event.payload?.message || this.terminalErrorMessage || 'Agent session failed';
+        return;
+      }
 
-    if (
-      payload.type === 'codex-response' &&
-      payload.data?.type === 'item_done' &&
-      payload.data?.itemType === 'agent_message' &&
-      typeof payload.data?.content === 'string' &&
-      payload.data.content.trim()
-    ) {
-      this.assistantMessages.push({
-        type: 'assistant',
-        message: {
-          role: 'assistant',
-          content: payload.data.content
+      if (payload.event.kind === CONVERSATION_EVENT_KINDS.SESSION_STATE_CHANGED) {
+        const nextState = String(payload.event.payload?.state || '').trim().toLowerCase();
+        if (nextState === 'completed') {
+          this.terminalState = 'completed';
+          this.terminalErrorMessage = null;
+        } else if (nextState === 'aborted') {
+          this.terminalState = 'aborted';
+          this.terminalErrorMessage = 'Session aborted';
+        } else if (nextState === 'errored') {
+          this.terminalState = 'errored';
+          this.terminalErrorMessage = payload.event.payload?.message || this.terminalErrorMessage || 'Agent session failed';
         }
-      });
+      }
+
+      return;
     }
 
     if (payload.type === 'session-aborted') {
@@ -335,7 +369,16 @@ export class CallbackCaptureWriter {
   }
 
   getAssistantMessages() {
-    return this.assistantMessages;
+    return this.timelineMessages
+      .filter((message) => message?.type === 'assistant' && !message?.isToolUse && !message?.isSystemNotice)
+      .map((message) => ({
+        type: 'assistant',
+        message: {
+          role: 'assistant',
+          content: message.content || ''
+        },
+        timestamp: message.timestamp || null
+      }));
   }
 
   getTotalTokens() {
@@ -394,52 +437,19 @@ async function ensureProjectPathExists(projectPath) {
 }
 
 async function runProviderSession({ provider, message, images, finalProjectPath, sessionId, model, writer }) {
-  if (provider === 'claude') {
-    await queryClaudeSDK(message, {
+  await executeAgentPrompt({
+    agentKey: provider,
+    command: message,
+    options: {
       projectPath: finalProjectPath,
       cwd: finalProjectPath,
       sessionId,
       model,
       permissionMode: 'bypassPermissions',
       images
-    }, writer);
-    return;
-  }
-
-  if (provider === 'codex') {
-    await queryCodex(message, {
-      projectPath: finalProjectPath,
-      cwd: finalProjectPath,
-      sessionId,
-      model: model || CODEX_MODELS.DEFAULT,
-      permissionMode: 'bypassPermissions',
-      images
-    }, writer);
-    return;
-  }
-
-  if (provider === 'gemini') {
-    await queryGemini(message, {
-      projectPath: finalProjectPath,
-      cwd: finalProjectPath,
-      sessionId,
-      resume: !!sessionId,
-      model: model || GEMINI_MODELS.DEFAULT,
-      permissionMode: 'bypassPermissions'
-    }, writer);
-    return;
-  }
-
-  if (provider === 'opencode') {
-    await queryOpencode(message, {
-      projectPath: finalProjectPath,
-      cwd: finalProjectPath,
-      sessionId,
-      resume: !!sessionId,
-      model: model || OPENCODE_MODELS.DEFAULT,
-      permissionMode: 'bypassPermissions'
-    }, writer);
-  }
+    },
+    writer
+  });
 }
 
 export async function runExternalAgentRequest({
@@ -459,6 +469,7 @@ export async function runExternalAgentRequest({
     const response = {
       success: true,
       openOnly: true,
+      runtime: 'acp',
       sessionId: normalized.normalizedSessionId,
       ...buildSessionNavigation(normalized.normalizedSessionId),
       isResumed: true,
@@ -467,6 +478,7 @@ export async function runExternalAgentRequest({
 
     transportWriter?.send?.({
       type: 'open-only',
+      runtime: 'acp',
       ...response
     });
 
@@ -484,6 +496,7 @@ export async function runExternalAgentRequest({
   let callbackResult = null;
 
   try {
+    await ensureProviderInstalled(normalized.provider);
     await ensureProjectPathExists(finalProjectPath);
 
     try {
@@ -525,6 +538,7 @@ export async function runExternalAgentRequest({
     const response = {
       success: true,
       sessionId: callbackSessionId,
+      runtime: 'acp',
       ...navigation,
       isResumed: !!normalized.normalizedSessionId,
       messages: callbackCaptureWriter.getAssistantMessages(),

package/server/gemini-cli.js

@@ -1,368 +1,31 @@
-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';
+import { GEMINI_MODELS } from '../shared/modelConstants.js';
+
+export async function queryGemini(command, options = {}, writer) {
+  return executeAgentPrompt({
+    agentKey: 'gemini',
+    command,
+    options: {
+      ...options,
+      model: options.model || GEMINI_MODELS.DEFAULT
+    },
+    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
-};