@axhub/genie 0.1.7 → 0.1.9

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/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

@@ -3,16 +3,22 @@ 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',
+  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
 
@@ -87,6 +93,7 @@ function buildInstallationStatus(provider, command, installed, resolvedPath, rea
     command,
     installed,
     reason,
+    installHint: PROVIDER_INSTALL_HINTS[provider] || null,
     resolvedPath,
     checkedAt: new Date().toISOString(),
     cacheHit,
@@ -114,18 +121,56 @@ async function detectProviderInstallationStatus(provider) {
   }
 
   const detectionPromise = (async () => {
-    const commandCheck = await resolveCommandPath(command);
-    const installed = commandCheck.found;
-    const status = buildInstallationStatus(
-      provider,
-      command,
-      installed,
-      commandCheck.resolvedPath,
-      commandCheck.reason,
-      false
-    );
-
-    if (installed) {
+    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
@@ -200,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 {
@@ -283,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
@@ -290,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 {
@@ -510,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' };
@@ -531,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',