@axhub/genie 0.1.6 → 0.1.8

package/server/routes/agent.js

@@ -9,8 +9,10 @@ import { addProjectManually } from '../projects.js';
 import { queryClaudeSDK } from '../claude-sdk.js';
 import { spawnCursor } from '../cursor-cli.js';
 import { queryCodex } from '../openai-codex.js';
+import { queryGemini } from '../gemini-cli.js';
+import { queryOpencode } from '../opencode-cli.js';
 import { Octokit } from '@octokit/rest';
-import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS } from '../../shared/modelConstants.js';
+import { CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
 import { IS_PLATFORM } from '../constants/config.js';
 
 const router = express.Router();
@@ -19,7 +21,11 @@ function buildSessionNavigation(sessionId) {
   const normalizedSessionId = typeof sessionId === 'string' && sessionId.trim() ? sessionId.trim() : null;
   const sessionPath = normalizedSessionId ? `/session/${normalizedSessionId}` : null;
   const frontendPort = process.env.VITE_PORT || '5173';
-  const sessionUrl = normalizedSessionId ? `http://localhost:${frontendPort}${sessionPath}` : null;
+  const configuredFrontendUrl = typeof process.env.FRONTEND_URL === 'string'
+    ? process.env.FRONTEND_URL.trim().replace(/\/+$/, '')
+    : '';
+  const frontendBaseUrl = configuredFrontendUrl || `http://localhost:${frontendPort}`;
+  const sessionUrl = normalizedSessionId ? `${frontendBaseUrl}${sessionPath}` : null;
 
   return {
     sessionPath,
@@ -633,7 +639,7 @@ class ResponseCollector {
 /**
  * POST /api/agent
  *
- * Trigger an AI agent (Claude or Cursor) to work on a project.
+ * Trigger an AI agent (Claude, Cursor, Codex, or Gemini) to work on a project.
  * Supports automatic GitHub branch and pull request creation after successful completion.
  *
  * ================================================================================================
@@ -661,7 +667,7 @@ class ResponseCollector {
  * @param {string} sessionId - (Optional) Existing session ID to resume.
  *                            If provided, the request continues that session instead of creating a new one.
  *
- * @param {string} provider - (Optional) AI provider to use. Options: 'claude' | 'cursor'
+ * @param {string} provider - (Optional) AI provider to use. Options: 'claude' | 'cursor' | 'codex' | 'gemini'
  *                           Default: 'claude'
  *
  * @param {boolean} stream - (Optional) Enable Server-Sent Events (SSE) streaming for real-time updates.
@@ -677,6 +683,7 @@ class ResponseCollector {
  *                                       'gpt-5.1-codex', 'gpt-5.1-codex-high', 'gpt-5.1-codex-max',
  *                                       'gpt-5.1-codex-max-high', 'opus-4.1', 'grok', and thinking variants
  *                        Codex models: 'gpt-5.2' (default), 'gpt-5.1-codex-max', 'o3', 'o4-mini'
+ *                        Gemini models: 'gemini-2.5-pro' (default), 'gemini-2.5-flash', 'gemini-2.5-flash-lite'
  *
  * @param {boolean} cleanup - (Optional) Auto-cleanup project directory after completion.
  *                           Default: true
@@ -779,7 +786,7 @@ class ResponseCollector {
  * Input Validations (400 Bad Request):
  *   - Either githubUrl OR projectPath must be provided (not neither)
  *   - message must be non-empty string
- *   - provider must be 'claude' or 'cursor'
+ *   - provider must be 'claude', 'cursor', 'codex', or 'gemini'
  *   - createBranch/createPR requires githubUrl OR projectPath (not neither)
  *   - branchName must pass Git naming rules (if provided)
  *
@@ -872,7 +879,7 @@ router.post('/', validateExternalApiKey, async (req, res) => {
 
   // Parse stream and cleanup as booleans (handle string "true"/"false" from curl)
   const stream = req.body.stream === undefined ? true : (req.body.stream === true || req.body.stream === 'true');
-  const cleanup = req.body.cleanup === undefined ? true : (req.body.cleanup === true || req.body.cleanup === 'true');
+  const requestedCleanup = req.body.cleanup === undefined ? true : (req.body.cleanup === true || req.body.cleanup === 'true');
 
   // If branchName is provided, automatically enable createBranch
   const createBranch = branchName ? true : (req.body.createBranch === true || req.body.createBranch === 'true');
@@ -881,10 +888,13 @@ router.post('/', validateExternalApiKey, async (req, res) => {
   const normalizedMessage = typeof message === 'string' ? message.trim() : '';
   const requestedOpenOnly = openOnly === true || openOnly === 'true';
   const isOpenOnly = requestedOpenOnly || (!normalizedMessage && !!normalizedSessionId);
+  // Keep openOnly requests backward-compatible with existing docs/examples:
+  // cleanup is irrelevant when we only generate session navigation.
+  const cleanup = isOpenOnly ? false : requestedCleanup;
 
   // Validate inputs
-  if (!['claude', 'cursor', 'codex'].includes(provider)) {
-    return res.status(400).json({ error: 'provider must be "claude", "cursor", or "codex"' });
+  if (!['claude', 'cursor', 'codex', 'gemini', 'opencode'].includes(provider)) {
+    return res.status(400).json({ error: 'provider must be "claude", "cursor", "codex", "gemini", or "opencode"' });
   }
 
   if (sessionId !== undefined && (typeof sessionId !== 'string' || !sessionId.trim())) {
@@ -911,10 +921,6 @@ router.post('/', validateExternalApiKey, async (req, res) => {
     return res.status(400).json({ error: 'createBranch and createPR are not supported when openOnly=true' });
   }
 
-  if (isOpenOnly && cleanup) {
-    return res.status(400).json({ error: 'cleanup is not supported when openOnly=true' });
-  }
-
   // Validate GitHub branch/PR creation requirements
   // Allow branch/PR creation with projectPath as long as it has a GitHub remote
   if ((createBranch || createPR) && !githubUrl && !projectPath) {
@@ -1062,6 +1068,28 @@ router.post('/', validateExternalApiKey, async (req, res) => {
         model: model || CODEX_MODELS.DEFAULT,
         permissionMode: 'bypassPermissions'
       }, writer);
+    } else if (provider === 'gemini') {
+      console.log('💎 Starting Gemini CLI session');
+
+      await queryGemini(normalizedMessage, {
+        projectPath: finalProjectPath,
+        cwd: finalProjectPath,
+        sessionId: normalizedSessionId,
+        resume: !!normalizedSessionId,
+        model: model || GEMINI_MODELS.DEFAULT,
+        permissionMode: 'bypassPermissions'
+      }, writer);
+    } else if (provider === 'opencode') {
+      console.log('🧠 Starting OpenCode CLI session');
+
+      await queryOpencode(normalizedMessage, {
+        projectPath: finalProjectPath,
+        cwd: finalProjectPath,
+        sessionId: normalizedSessionId,
+        resume: !!normalizedSessionId,
+        model: model || OPENCODE_MODELS.DEFAULT,
+        permissionMode: 'bypassPermissions'
+      }, writer);
     }
 
     // Handle GitHub branch and PR creation after successful agent completion

package/server/routes/channels.js

@@ -0,0 +1,221 @@
+import express from 'express';
+
+import { getChannelManager } from '../channels/index.js';
+
+const router = express.Router();
+
+const SUPPORTED_PLATFORMS = new Set(['lark', 'dingtalk']);
+
+function parseBoolean(value) {
+  if (value === true || value === 'true' || value === 1 || value === '1') {
+    return true;
+  }
+  if (value === false || value === 'false' || value === 0 || value === '0') {
+    return false;
+  }
+  return null;
+}
+
+function normalizePlatform(value) {
+  const platform = String(value || '').trim().toLowerCase();
+  return SUPPORTED_PLATFORMS.has(platform) ? platform : null;
+}
+
+async function resolveManager(req, res) {
+  const platform = normalizePlatform(req.params.platform);
+  if (!platform) {
+    res.status(400).json({ success: false, error: 'unsupported platform' });
+    return null;
+  }
+
+  const manager = getChannelManager();
+  await manager.initialize();
+  return { manager, platform };
+}
+
+router.get('/:platform/config', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    res.json({ success: true, config: manager.getConfig(platform) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.put('/:platform/config', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    const config = manager.updateConfig(platform, req.body || {});
+    res.json({ success: true, config });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/:platform/test', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    const result =
+      platform === 'dingtalk'
+        ? await manager.testConnection(platform, {
+            clientId: String(req.body?.clientId || '').trim(),
+            clientSecret: String(req.body?.clientSecret || '').trim(),
+          })
+        : await manager.testConnection(platform, {
+            appId: String(req.body?.appId || '').trim(),
+            appSecret: String(req.body?.appSecret || '').trim(),
+          });
+
+    if (!result.success) {
+      return res.status(400).json(result);
+    }
+
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/:platform/start', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    const status = await manager.startPlugin(platform);
+    res.json({ success: true, status });
+  } catch (error) {
+    res.status(400).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/:platform/stop', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    const status = await manager.stopPlugin(platform);
+    res.json({ success: true, status });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/:platform/status', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    res.json({ success: true, status: manager.getStatus(platform) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/:platform/allowed-users', async (req, res) => {
+  try {
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+    res.json({ success: true, users: manager.listAllowedUsers(platform) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/:platform/allowed-users', async (req, res) => {
+  try {
+    const userId = String(req.body?.userId || '').trim();
+    const displayName = req.body?.displayName;
+    const note = req.body?.note;
+
+    if (!userId) {
+      return res.status(400).json({ success: false, error: 'userId is required' });
+    }
+
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+
+    const user = manager.addAllowedUser(platform, {
+      userId,
+      displayName,
+      note,
+    });
+
+    res.json({ success: true, user });
+  } catch (error) {
+    if (String(error.message || '').includes('UNIQUE')) {
+      return res.status(409).json({ success: false, error: '该用户ID已存在' });
+    }
+
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.patch('/:platform/allowed-users/:id/toggle', async (req, res) => {
+  try {
+    const id = Number(req.params.id);
+    const isActive = parseBoolean(req.body?.isActive);
+
+    if (!Number.isFinite(id)) {
+      return res.status(400).json({ success: false, error: 'invalid id' });
+    }
+
+    if (isActive === null) {
+      return res.status(400).json({ success: false, error: 'isActive must be boolean' });
+    }
+
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+
+    const ok = manager.toggleAllowedUser(platform, id, isActive);
+    if (!ok) {
+      return res.status(404).json({ success: false, error: 'user not found' });
+    }
+
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/:platform/allowed-users/:id', async (req, res) => {
+  try {
+    const id = Number(req.params.id);
+    if (!Number.isFinite(id)) {
+      return res.status(400).json({ success: false, error: 'invalid id' });
+    }
+
+    const resolved = await resolveManager(req, res);
+    if (!resolved) return;
+
+    const { manager, platform } = resolved;
+
+    const ok = manager.removeAllowedUser(platform, id);
+    if (!ok) {
+      return res.status(404).json({ success: false, error: 'user not found' });
+    }
+
+    res.json({ success: true });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/routes/cli-auth.js

@@ -5,6 +5,218 @@ import path from 'path';
 import os from 'os';
 
 const router = express.Router();
+const INSTALLATION_CACHE_TTL_MS = 12 * 60 * 60 * 1000;
+const SUPPORTED_PROVIDER_COMMANDS = {
+  claude: 'claude',
+  cursor: 'cursor-agent',
+  codex: 'codex',
+  gemini: 'gemini',
+  opencode: 'opencode'
+};
+const PROVIDER_INSTALL_HINTS = {
+  claude: 'Install Claude Code CLI: npm i -g @anthropic-ai/claude-code',
+  cursor: 'Install Cursor Agent CLI: npm i -g @cursor-ai/cursor-agent',
+  codex: 'Install Codex CLI: npm i -g @openai/codex',
+  gemini: 'Install Gemini CLI: npm i -g @google/gemini-cli',
+  opencode: 'Install OpenCode CLI: npm i -g opencode-ai'
+};
+const installationStatusCache = new Map(); // provider -> status
+const installationStatusInFlight = new Map(); // provider -> Promise
+
+function getLocatorCommand() {
+  return process.platform === 'win32' ? 'where' : 'which';
+}
+
+function resolveCommandPath(command) {
+  return new Promise((resolve) => {
+    let childProcess;
+    let stdout = '';
+    let stderr = '';
+
+    try {
+      childProcess = spawn(getLocatorCommand(), [command], {
+        stdio: ['ignore', 'pipe', 'pipe']
+      });
+    } catch (error) {
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `Failed to run command locator: ${error.message}`
+      });
+      return;
+    }
+
+    childProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    childProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    childProcess.on('close', (code) => {
+      const lines = stdout
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(Boolean);
+      const resolvedPath = lines[0] || null;
+
+      if (code === 0 && resolvedPath) {
+        resolve({
+          found: true,
+          resolvedPath,
+          reason: null
+        });
+        return;
+      }
+
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `${command} not found in PATH${stderr?.trim() ? ` (${stderr.trim()})` : ''}`
+      });
+    });
+
+    childProcess.on('error', (error) => {
+      resolve({
+        found: false,
+        resolvedPath: null,
+        reason: `Failed to detect ${command}: ${error.message}`
+      });
+    });
+  });
+}
+
+function buildInstallationStatus(provider, command, installed, resolvedPath, reason, cacheHit = false) {
+  return {
+    success: true,
+    provider,
+    command,
+    installed,
+    reason,
+    installHint: PROVIDER_INSTALL_HINTS[provider] || null,
+    resolvedPath,
+    checkedAt: new Date().toISOString(),
+    cacheHit,
+    ttlMs: INSTALLATION_CACHE_TTL_MS
+  };
+}
+
+async function detectProviderInstallationStatus(provider) {
+  const command = SUPPORTED_PROVIDER_COMMANDS[provider];
+  if (!command) {
+    throw new Error(`Unsupported provider: ${provider}`);
+  }
+
+  const now = Date.now();
+  const cached = installationStatusCache.get(provider);
+  if (cached && cached.expiresAt > now) {
+    return {
+      ...cached.status,
+      cacheHit: true
+    };
+  }
+
+  if (installationStatusInFlight.has(provider)) {
+    return installationStatusInFlight.get(provider);
+  }
+
+  const detectionPromise = (async () => {
+    let status;
+
+    if (provider === 'opencode') {
+      const [opencodeCheck, npxCheck] = await Promise.all([
+        resolveCommandPath('opencode'),
+        resolveCommandPath('npx')
+      ]);
+
+      if (opencodeCheck.found) {
+        status = buildInstallationStatus(
+          provider,
+          'opencode',
+          true,
+          opencodeCheck.resolvedPath,
+          null,
+          false
+        );
+      } else if (npxCheck.found) {
+        status = buildInstallationStatus(
+          provider,
+          'npx (fallback: opencode-ai@latest)',
+          true,
+          npxCheck.resolvedPath,
+          'OpenCode binary not found in PATH. Axhub Genie will use npx fallback.',
+          false
+        );
+      } else {
+        status = buildInstallationStatus(
+          provider,
+          'opencode',
+          false,
+          null,
+          opencodeCheck.reason || npxCheck.reason || 'OpenCode and npx are not available in PATH',
+          false
+        );
+      }
+    } else {
+      const commandCheck = await resolveCommandPath(command);
+      const installed = commandCheck.found;
+      status = buildInstallationStatus(
+        provider,
+        command,
+        installed,
+        commandCheck.resolvedPath,
+        commandCheck.reason,
+        false
+      );
+    }
+
+    if (status.installed) {
+      installationStatusCache.set(provider, {
+        status,
+        expiresAt: now + INSTALLATION_CACHE_TTL_MS
+      });
+    } else {
+      installationStatusCache.delete(provider);
+    }
+
+    return status;
+  })();
+
+  installationStatusInFlight.set(provider, detectionPromise);
+
+  try {
+    return await detectionPromise;
+  } finally {
+    installationStatusInFlight.delete(provider);
+  }
+}
+
+router.get('/providers/:provider/installation-status', async (req, res) => {
+  try {
+    const provider = String(req.params.provider || '').toLowerCase();
+    if (!Object.prototype.hasOwnProperty.call(SUPPORTED_PROVIDER_COMMANDS, provider)) {
+      return res.status(400).json({
+        success: false,
+        error: `Unsupported provider: ${provider}`
+      });
+    }
+
+    const forceRefresh = String(req.query.force || '').toLowerCase() === 'true';
+    if (forceRefresh) {
+      installationStatusCache.delete(provider);
+    }
+
+    const status = await detectProviderInstallationStatus(provider);
+    return res.json(status);
+  } catch (error) {
+    console.error('Error checking provider installation status:', error);
+    return res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
 
 router.get('/claude/status', async (req, res) => {
   try {
@@ -74,6 +286,26 @@ router.get('/codex/status', async (req, res) => {
   }
 });
 
+router.get('/gemini/status', async (req, res) => {
+  try {
+    const result = await checkGeminiCredentials();
+
+    res.json({
+      authenticated: result.authenticated,
+      email: result.email,
+      error: result.error
+    });
+
+  } catch (error) {
+    console.error('Error checking Gemini auth status:', error);
+    res.status(500).json({
+      authenticated: false,
+      email: null,
+      error: error.message
+    });
+  }
+});
+
 async function checkClaudeCredentials() {
   try {
     const credPath = path.join(os.homedir(), '.claude', '.credentials.json');
@@ -260,4 +492,89 @@ async function checkCodexCredentials() {
   }
 }
 
+async function checkGeminiCredentials() {
+  try {
+    const geminiDir = path.join(os.homedir(), '.gemini');
+    const oauthCredPath = path.join(geminiDir, 'oauth_creds.json');
+    const content = await fs.readFile(oauthCredPath, 'utf8');
+    const creds = JSON.parse(content);
+
+    if (creds?.access_token || creds?.refresh_token || creds?.token) {
+      return {
+        authenticated: true,
+        email: creds?.email || 'Authenticated'
+      };
+    }
+
+    return {
+      authenticated: false,
+      email: null,
+      error: 'No valid Gemini credentials found'
+    };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {
+        authenticated: false,
+        email: null,
+        error: 'Gemini not configured'
+      };
+    }
+
+    return {
+      authenticated: false,
+      email: null,
+      error: error.message
+    };
+  }
+}
+
+// OpenCode status helper
+async function checkOpencodeCredentials() {
+  try {
+    const candidates = [
+      path.join(os.homedir(), '.config', 'opencode', 'auth.json'),
+      path.join(os.homedir(), '.opencode', 'auth.json')
+    ];
+    let anyFileAccessible = false;
+    for (const p of candidates) {
+      try {
+        await fs.access(p);
+        anyFileAccessible = true;
+        const raw = await fs.readFile(p, 'utf8');
+        const data = JSON.parse(raw);
+        const token = data?.access_token || data?.token || data?.api_key;
+        if (token) {
+          const email = data.email || 'Authenticated';
+          return { authenticated: true, email, error: null };
+        }
+        // else try next candidate
+      } catch (err) {
+        // ignore and try next
+        continue;
+      }
+    }
+    if (anyFileAccessible) {
+      return { authenticated: false, email: null, error: 'Invalid OpenCode credentials format' };
+    }
+    return { authenticated: false, email: null, error: 'OpenCode not configured' };
+  } catch (error) {
+    return { authenticated: false, email: null, error: 'OpenCode not configured' };
+  }
+}
+
+// Route: GET /opencode/status
+router.get('/opencode/status', async (req, res) => {
+  try {
+    const result = await checkOpencodeCredentials();
+    res.json({
+      authenticated: result.authenticated,
+      email: result.email,
+      error: result.error
+    });
+  } catch (error) {
+    console.error('Error checking OpenCode auth status:', error);
+    res.status(500).json({ authenticated: false, email: null, error: error.message });
+  }
+});
+
 export default router;