@axhub/genie 0.1.8 → 0.2.0

package/server/routes/auth.js

@@ -1,6 +1,6 @@
 import express from 'express';
 import bcrypt from 'bcrypt';
-import { userDb, db } from '../database/db.js';
+import { userDb } from '../database/db.js';
 import { generateToken, authenticateToken } from '../middleware/auth.js';
 
 const router = express.Router();
@@ -33,45 +33,23 @@ router.post('/register', async (req, res) => {
       return res.status(400).json({ error: 'Username must be at least 3 characters, password at least 6 characters' });
     }
     
-    // Use a transaction to prevent race conditions
-    db.prepare('BEGIN').run();
-    try {
-      // Check if users already exist (only allow one user)
-      const hasUsers = userDb.hasUsers();
-      if (hasUsers) {
-        db.prepare('ROLLBACK').run();
-        return res.status(403).json({ error: 'User already exists. This is a single-user system.' });
-      }
-      
-      // Hash password
-      const saltRounds = 12;
-      const passwordHash = await bcrypt.hash(password, saltRounds);
-      
-      // Create user
-      const user = userDb.createUser(username, passwordHash);
-      
-      // Generate token
-      const token = generateToken(user);
-      
-      // Update last login
-      userDb.updateLastLogin(user.id);
+    const saltRounds = 12;
+    const passwordHash = await bcrypt.hash(password, saltRounds);
+    const user = userDb.registerUser(username, passwordHash);
+    const token = generateToken(user);
 
-      db.prepare('COMMIT').run();
-      
-      res.json({
-        success: true,
-        user: { id: user.id, username: user.username },
-        token
-      });
-    } catch (error) {
-      db.prepare('ROLLBACK').run();
-      throw error;
-    }
+    res.json({
+      success: true,
+      user: { id: user.id, username: user.username },
+      token
+    });
     
   } catch (error) {
     console.error('Registration error:', error);
-    if (error.code === 'SQLITE_CONSTRAINT_UNIQUE') {
+    if (error.code === 'USERNAME_EXISTS') {
       res.status(409).json({ error: 'Username already exists' });
+    } else if (error.code === 'USER_EXISTS') {
+      res.status(403).json({ error: 'User already exists. This is a single-user system.' });
     } else {
       res.status(500).json({ error: 'Internal server error' });
     }
@@ -132,4 +110,4 @@ router.post('/logout', authenticateToken, (req, res) => {
   res.json({ success: true, message: 'Logged out successfully' });
 });
 
-export default router;
+export default router;

package/server/routes/cli-auth.js

@@ -3,19 +3,18 @@ import { spawn } from 'child_process';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
+import { listOpencodeModels } from '../opencode-cli.js';
 
 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'
@@ -246,25 +245,6 @@ router.get('/claude/status', async (req, res) => {
   }
 });
 
-router.get('/cursor/status', async (req, res) => {
-  try {
-    const result = await checkCursorStatus();
-
-    res.json({
-      authenticated: result.authenticated,
-      email: result.email,
-      error: result.error
-    });
-
-  } catch (error) {
-    console.error('Error checking Cursor auth status:', error);
-    res.status(500).json({
-      authenticated: false,
-      email: null,
-      error: error.message
-    });
-  }
-});
 
 router.get('/codex/status', async (req, res) => {
   try {
@@ -329,6 +309,27 @@ async function checkClaudeCredentials() {
       email: null
     };
   } catch (error) {
+    try {
+      const configPath = path.join(os.homedir(), '.claude', 'config.json');
+      const configContent = await fs.readFile(configPath, 'utf8');
+      const config = JSON.parse(configContent);
+
+      if (typeof config?.primaryApiKey === 'string' && config.primaryApiKey.trim()) {
+        return {
+          authenticated: true,
+          email: 'API Key Auth'
+        };
+      }
+    } catch {
+    }
+
+    if (typeof process.env.ANTHROPIC_API_KEY === 'string' && process.env.ANTHROPIC_API_KEY.trim()) {
+      return {
+        authenticated: true,
+        email: 'API Key Auth'
+      };
+    }
+
     return {
       authenticated: false,
       email: null
@@ -336,98 +337,6 @@ async function checkClaudeCredentials() {
   }
 }
 
-function checkCursorStatus() {
-  return new Promise((resolve) => {
-    let processCompleted = false;
-
-    const timeout = setTimeout(() => {
-      if (!processCompleted) {
-        processCompleted = true;
-        if (childProcess) {
-          childProcess.kill();
-        }
-        resolve({
-          authenticated: false,
-          email: null,
-          error: 'Command timeout'
-        });
-      }
-    }, 5000);
-
-    let childProcess;
-    try {
-      childProcess = spawn('cursor-agent', ['status']);
-    } catch (err) {
-      clearTimeout(timeout);
-      processCompleted = true;
-      resolve({
-        authenticated: false,
-        email: null,
-        error: 'Cursor CLI not found or not installed'
-      });
-      return;
-    }
-
-    let stdout = '';
-    let stderr = '';
-
-    childProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    childProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    childProcess.on('close', (code) => {
-      if (processCompleted) return;
-      processCompleted = true;
-      clearTimeout(timeout);
-
-      if (code === 0) {
-        const emailMatch = stdout.match(/Logged in as ([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/i);
-
-        if (emailMatch) {
-          resolve({
-            authenticated: true,
-            email: emailMatch[1],
-            output: stdout
-          });
-        } else if (stdout.includes('Logged in')) {
-          resolve({
-            authenticated: true,
-            email: 'Logged in',
-            output: stdout
-          });
-        } else {
-          resolve({
-            authenticated: false,
-            email: null,
-            error: 'Not logged in'
-          });
-        }
-      } else {
-        resolve({
-          authenticated: false,
-          email: null,
-          error: stderr || 'Not logged in'
-        });
-      }
-    });
-
-    childProcess.on('error', (err) => {
-      if (processCompleted) return;
-      processCompleted = true;
-      clearTimeout(timeout);
-
-      resolve({
-        authenticated: false,
-        email: null,
-        error: 'Cursor CLI not found or not installed'
-      });
-    });
-  });
-}
 
 async function checkCodexCredentials() {
   try {
@@ -556,6 +465,37 @@ async function checkOpencodeCredentials() {
     if (anyFileAccessible) {
       return { authenticated: false, email: null, error: 'Invalid OpenCode credentials format' };
     }
+
+    const configCandidates = [
+      path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
+      path.join(os.homedir(), '.opencode', 'opencode.json')
+    ];
+
+    for (const configPath of configCandidates) {
+      try {
+        const raw = await fs.readFile(configPath, 'utf8');
+        const config = JSON.parse(raw);
+        const providers = config?.provider;
+
+        if (providers && typeof providers === 'object' && Object.keys(providers).length > 0) {
+          return { authenticated: true, email: 'Configured', error: null };
+        }
+      } catch {
+      }
+    }
+
+    try {
+      const discovery = await Promise.race([
+        listOpencodeModels({ cwd: process.cwd() }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 8000))
+      ]);
+
+      if (Array.isArray(discovery?.models) && discovery.models.length > 0) {
+        return { authenticated: true, email: 'Configured', error: null };
+      }
+    } catch {
+    }
+
     return { authenticated: false, email: null, error: 'OpenCode not configured' };
   } catch (error) {
     return { authenticated: false, email: null, error: 'OpenCode not configured' };
@@ -577,4 +517,11 @@ router.get('/opencode/status', async (req, res) => {
   }
 });
 
+export {
+  detectProviderInstallationStatus,
+  checkClaudeCredentials,  checkCodexCredentials,
+  checkGeminiCredentials,
+  checkOpencodeCredentials
+};
+
 export default router;

package/server/routes/commands.js

@@ -4,8 +4,8 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import os from 'os';
 import matter from 'gray-matter';
-import { CLAUDE_MODELS, CURSOR_MODELS, CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
-import { listOpencodeModels } from '../opencode-cli.js';
+import { CLAUDE_MODELS, CODEX_MODELS, GEMINI_MODELS, OPENCODE_MODELS } from '../../shared/modelConstants.js';
+import { discoverAllProviders } from '../session-core/providerDiscovery.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -184,39 +184,29 @@ Custom commands can be created in:
   },
 
   '/model': async (args, context) => {
-    // Read available models from centralized constants
-    const availableModels = {
-      claude: CLAUDE_MODELS.OPTIONS.map(o => o.value),
-      cursor: CURSOR_MODELS.OPTIONS.map(o => o.value),
-      codex: CODEX_MODELS.OPTIONS.map(o => o.value),
-      gemini: GEMINI_MODELS.OPTIONS.map(o => o.value),
-      opencode: OPENCODE_MODELS.OPTIONS.map(o => o.value)
-    };
+    const providerDiscovery = await discoverAllProviders({ projectPath: context?.projectPath });
+    const availableModels = providerDiscovery.reduce((acc, item) => {
+      acc[item.provider] = Array.isArray(item.models) && item.models.length > 0
+        ? item.models.map((entry) => entry.id)
+        : (item.provider === 'claude'
+          ? CLAUDE_MODELS.OPTIONS.map(o => o.value)
+            : item.provider === 'codex'
+              ? CODEX_MODELS.OPTIONS.map(o => o.value)
+              : item.provider === 'gemini'
+                ? GEMINI_MODELS.OPTIONS.map(o => o.value)
+                : OPENCODE_MODELS.OPTIONS.map(o => o.value));
+      return acc;
+    }, {});
 
     const currentProvider = context?.provider || 'claude';
     const providerDefaults = {
       claude: CLAUDE_MODELS.DEFAULT,
-      cursor: CURSOR_MODELS.DEFAULT,
       codex: CODEX_MODELS.DEFAULT,
       gemini: GEMINI_MODELS.DEFAULT,
       opencode: OPENCODE_MODELS.DEFAULT
     };
     const currentModel = context?.model || providerDefaults[currentProvider] || CLAUDE_MODELS.DEFAULT;
-    let opencodeDiscovery = null;
-
-    if (context?.projectPath) {
-      try {
-        opencodeDiscovery = await listOpencodeModels({
-          projectPath: context?.projectPath,
-          cwd: context?.projectPath
-        });
-        if (opencodeDiscovery.models.length > 0) {
-          availableModels.opencode = opencodeDiscovery.models;
-        }
-      } catch (error) {
-        console.warn('Failed to query OpenCode runtime models:', error.message);
-      }
-    }
+    const opencodeDiscovery = providerDiscovery.find((item) => item.provider === 'opencode') || null;
 
     return {
       type: 'builtin',

package/server/routes/git.js

@@ -5,7 +5,6 @@ import path from 'path';
 import { promises as fs } from 'fs';
 import { extractProjectDirectory } from '../projects.js';
 import { queryClaudeSDK } from '../claude-sdk.js';
-import { spawnCursor } from '../cursor-cli.js';
 import { queryGemini } from '../gemini-cli.js';
 
 const router = express.Router();
@@ -520,8 +519,8 @@ router.post('/generate-commit-message', async (req, res) => {
   }
 
   // Validate provider
-  if (!['claude', 'cursor', 'gemini'].includes(provider)) {
-    return res.status(400).json({ error: 'provider must be "claude", "cursor", or "gemini"' });
+  if (!['claude', 'gemini'].includes(provider)) {
+    return res.status(400).json({ error: 'provider must be "claude" or "gemini"' });
   }
 
   try {
@@ -574,10 +573,10 @@ router.post('/generate-commit-message', async (req, res) => {
 });
 
 /**
- * Generates a commit message using AI (Claude SDK, Cursor CLI, or Gemini CLI)
+ * Generates a commit message using AI (Claude SDK, Codex, Gemini, or OpenCode)
  * @param {Array<string>} files - List of changed files
  * @param {string} diffContext - Git diff content
- * @param {string} provider - 'claude', 'cursor', or 'gemini'
+ * @param {string} provider - 'claude' or 'gemini'
  * @param {string} projectPath - Project directory path
  * @returns {Promise<string>} Generated commit message
  */
@@ -611,7 +610,7 @@ Generate the commit message:`;
           const parsed = typeof data === 'string' ? JSON.parse(data) : data;
           console.log('🔍 Writer received message type:', parsed.type);
 
-          // Handle different message formats from Claude SDK and Cursor CLI
+          // Handle different message formats from supported providers
           // Claude SDK sends: {type: 'claude-response', data: {message: {content: [...]}}}
           if (parsed.type === 'claude-response' && parsed.data) {
             const message = parsed.data.message || parsed.data;
@@ -626,11 +625,6 @@ Generate the commit message:`;
               }
             }
           }
-          // Cursor CLI sends: {type: 'cursor-output', output: '...'}
-          else if (parsed.type === 'cursor-output' && parsed.output) {
-            console.log('✅ Cursor output:', parsed.output.substring(0, 100));
-            responseText += parsed.output;
-          }
           else if (parsed.type === 'claude-response' && parsed.data?.type === 'content_block_delta' && parsed.data?.delta?.text) {
             responseText += parsed.data.delta.text;
           }
@@ -657,11 +651,6 @@ Generate the commit message:`;
         permissionMode: 'bypassPermissions',
         model: 'sonnet'
       }, writer);
-    } else if (provider === 'cursor') {
-      await spawnCursor(prompt, {
-        cwd: projectPath,
-        skipPermissions: true
-      }, writer);
     } else if (provider === 'gemini') {
       await queryGemini(prompt, {
         cwd: projectPath,

package/server/routes/projects.js

@@ -4,6 +4,7 @@ import path from 'path';
 import { spawn } from 'child_process';
 import os from 'os';
 import { addProjectManually } from '../projects.js';
+import { githubTokensDb } from '../database/db.js';
 
 const router = express.Router();
 
@@ -311,13 +312,7 @@ router.post('/create-workspace', async (req, res) => {
  * Helper function to get GitHub token from database
  */
 async function getGithubTokenById(tokenId, userId) {
-  const { getDatabase } = await import('../database/db.js');
-  const db = await getDatabase();
-
-  const credential = await db.get(
-    'SELECT * FROM user_credentials WHERE id = ? AND user_id = ? AND credential_type = ? AND is_active = 1',
-    [tokenId, userId, 'github_token']
-  );
+  const credential = githubTokensDb.getGithubTokenById(userId, tokenId);
 
   // Return in the expected format (github_token field for compatibility)
   if (credential) {

package/server/routes/session-core.js

@@ -0,0 +1,177 @@
+import express from 'express';
+import { getProjects } from '../projects.js';
+import { discoverAllProviders, discoverProvider } from '../session-core/providerDiscovery.js';
+import { getProviderAdapter } from '../session-core/providerAdapters.js';
+
+const router = express.Router();
+
+function flattenProjectSessions(project) {
+  const groups = [
+    { provider: 'claude', items: project.sessions || [] },
+    { provider: 'codex', items: project.codexSessions || [] },
+    { provider: 'gemini', items: project.geminiSessions || [] },
+    { provider: 'opencode', items: project.opencodeSessions || [] }
+  ];
+
+  return groups.flatMap(({ provider, items }) => items.map((item) => ({ ...item, provider, __provider: provider })))
+    .sort((a, b) => new Date(b.lastActivity || b.updated_at || b.createdAt || 0) - new Date(a.lastActivity || a.updated_at || a.createdAt || 0));
+}
+
+router.get('/providers', async (req, res) => {
+  try {
+    const providers = await discoverAllProviders({ projectPath: req.query.projectPath });
+    res.json({ success: true, providers });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/providers/:provider', async (req, res) => {
+  try {
+    const result = await discoverProvider(req.params.provider, { projectPath: req.query.projectPath });
+    res.json({ success: true, ...result });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/projects/:projectName/history-index', async (req, res) => {
+  try {
+    const projects = await getProjects();
+    const project = projects.find((entry) => entry.name === req.params.projectName);
+    if (!project) {
+      return res.status(404).json({ success: false, error: 'Project not found' });
+    }
+    res.json({ success: true, project: { name: project.name, fullPath: project.fullPath || project.path, displayName: project.displayName || project.name }, sessions: flattenProjectSessions(project) });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions/:sessionId/resolve', async (req, res) => {
+  try {
+    const projects = await getProjects();
+    const requestedSessionId = String(req.params.sessionId || '').trim();
+    const providerHint = typeof req.query.provider === 'string' ? req.query.provider.trim().toLowerCase() : '';
+
+    if (!requestedSessionId) {
+      return res.status(400).json({ success: false, error: 'Session id is required' });
+    }
+
+    const providerOrder = [
+      providerHint,
+      'codex',
+      'claude',
+      'gemini',
+      'opencode'
+    ].filter((provider, index, all) => provider && all.indexOf(provider) === index);
+
+    const directProjectMatch = projects.find((project) => {
+      const flattened = flattenProjectSessions(project);
+      return flattened.some((session) => session.id === requestedSessionId);
+    });
+
+    if (directProjectMatch) {
+      const flattened = flattenProjectSessions(directProjectMatch);
+      const matchedSession = flattened.find((session) => session.id === requestedSessionId);
+
+      return res.json({
+        success: true,
+        found: true,
+        provider: matchedSession.provider,
+        session: matchedSession,
+        project: {
+          name: directProjectMatch.name,
+          fullPath: directProjectMatch.fullPath || directProjectMatch.path,
+          path: directProjectMatch.path,
+          displayName: directProjectMatch.displayName || directProjectMatch.name
+        }
+      });
+    }
+
+    for (const provider of providerOrder) {
+      const adapter = getProviderAdapter(provider);
+
+      for (const project of projects) {
+        let sessions = [];
+
+        try {
+          if (provider === 'claude') {
+            const result = await adapter.listSessions({ projectName: project.name, limit: 1000, offset: 0 });
+            sessions = Array.isArray(result) ? result : [];
+          } else {
+            sessions = await adapter.listSessions({ projectPath: project.fullPath || project.path, limit: 0 });
+          }
+        } catch (error) {
+          continue;
+        }
+
+        const matchedSession = sessions.find((session) => session.id === requestedSessionId);
+        if (!matchedSession) {
+          continue;
+        }
+
+        return res.json({
+          success: true,
+          found: true,
+          provider,
+          session: matchedSession,
+          project: {
+            name: project.name,
+            fullPath: project.fullPath || project.path,
+            path: project.path,
+            displayName: project.displayName || project.name
+          }
+        });
+      }
+    }
+
+    res.status(404).json({ success: true, found: false });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/sessions/:provider/:sessionId/events', async (req, res) => {
+  try {
+    const adapter = getProviderAdapter(req.params.provider);
+    const parsedLimit = req.query.limit ? parseInt(req.query.limit, 10) : null;
+    const parsedOffset = req.query.offset ? parseInt(req.query.offset, 10) : 0;
+    const result = await adapter.loadEvents({
+      projectName: req.query.projectName,
+      projectPath: req.query.projectPath,
+      sessionId: req.params.sessionId,
+      limit: parsedLimit,
+      offset: parsedOffset
+    });
+
+    const events = Array.isArray(result) ? result : (result?.events || result?.messages || []);
+    const total = typeof result?.total === 'number' ? result.total : events.length;
+    const hasMore = typeof result?.hasMore === 'boolean' ? result.hasMore : false;
+    const offset = typeof result?.offset === 'number' ? result.offset : parsedOffset;
+    const limit = Object.prototype.hasOwnProperty.call(result || {}, 'limit')
+      ? result.limit
+      : parsedLimit;
+
+    const response = {
+      success: true,
+      provider: req.params.provider,
+      sessionId: req.params.sessionId,
+      events,
+      total,
+      hasMore,
+      offset,
+      limit
+    };
+
+    if (result && typeof result === 'object' && result.tokenUsage) {
+      response.tokenUsage = result.tokenUsage;
+    }
+
+    res.json(response);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+export default router;

package/server/session-core/abortSession.js

@@ -0,0 +1,48 @@
+import { abortClaudeSDKSession } from '../claude-sdk.js';
+import { abortCodexSession } from '../openai-codex.js';
+import { abortGeminiSession } from '../gemini-cli.js';
+import { abortOpencodeSession } from '../opencode-cli.js';
+
+export const ABORTABLE_AGENT_PROVIDERS = ['claude', 'codex', 'gemini', 'opencode'];
+
+export function isAbortableAgentProvider(provider) {
+  return ABORTABLE_AGENT_PROVIDERS.includes(String(provider || '').trim().toLowerCase());
+}
+
+export async function abortAgentSession(provider, sessionId) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+
+  if (normalizedProvider === 'codex') {
+    return abortCodexSession(sessionId);
+  }
+
+  if (normalizedProvider === 'gemini') {
+    return abortGeminiSession(sessionId);
+  }
+
+  if (normalizedProvider === 'opencode') {
+    return abortOpencodeSession(sessionId);
+  }
+
+  return abortClaudeSDKSession(sessionId);
+}
+
+export async function abortAgentSessionWithWriter({ provider = 'claude', sessionId, writer }) {
+  const normalizedProvider = String(provider || 'claude').trim().toLowerCase();
+  const success = await abortAgentSession(normalizedProvider, sessionId);
+  const payload = {
+    type: 'session-aborted',
+    sessionId,
+    provider: normalizedProvider,
+    success
+  };
+
+  if (writer && typeof writer.send === 'function') {
+    writer.send(payload);
+  }
+
+  return {
+    success,
+    payload
+  };
+}