@axhub/genie 0.2.2 → 0.2.4

package/server/routes/cli-auth.js

@@ -1,5 +1,5 @@
 import express from 'express';
-import { spawn } from 'child_process';
+import { constants as fsConstants } from 'fs';
 import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
@@ -26,64 +26,72 @@ 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;
+async function isRunnableCommand(candidatePath) {
+  try {
+    if (process.platform === 'win32') {
+      await fs.access(candidatePath, fsConstants.F_OK);
+      return true;
     }
 
-    childProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
+    await fs.access(candidatePath, fsConstants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-    childProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
+async function resolveCommandPath(command) {
+  const normalizedCommand = String(command || '').trim();
+  if (!normalizedCommand) {
+    return {
+      found: false,
+      resolvedPath: null,
+      reason: 'Command name is empty'
+    };
+  }
 
-    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;
+  const isDirectPath = normalizedCommand.includes(path.sep) || (process.platform === 'win32' && normalizedCommand.includes('/'));
+  const pathEntries = isDirectPath
+    ? ['']
+    : String(process.env.PATH || '')
+      .split(path.delimiter)
+      .map((entry) => entry.trim())
+      .filter(Boolean);
+
+  const windowsExtensions = process.platform === 'win32'
+    ? String(process.env.PATHEXT || '.EXE;.CMD;.BAT;.COM')
+      .split(';')
+      .map((ext) => ext.trim())
+      .filter(Boolean)
+    : [''];
+
+  const candidatePaths = [];
+  for (const baseDir of pathEntries) {
+    const baseCandidate = isDirectPath ? normalizedCommand : path.join(baseDir, normalizedCommand);
+    candidatePaths.push(baseCandidate);
+
+    if (process.platform === 'win32' && !path.extname(baseCandidate)) {
+      for (const ext of windowsExtensions) {
+        candidatePaths.push(`${baseCandidate}${ext}`);
       }
+    }
+  }
 
-      resolve({
-        found: false,
-        resolvedPath: null,
-        reason: `${command} not found in PATH${stderr?.trim() ? ` (${stderr.trim()})` : ''}`
-      });
-    });
+  for (const candidatePath of candidatePaths) {
+    if (await isRunnableCommand(candidatePath)) {
+      return {
+        found: true,
+        resolvedPath: candidatePath,
+        reason: null
+      };
+    }
+  }
 
-    childProcess.on('error', (error) => {
-      resolve({
-        found: false,
-        resolvedPath: null,
-        reason: `Failed to detect ${command}: ${error.message}`
-      });
-    });
-  });
+  return {
+    found: false,
+    resolvedPath: null,
+    reason: `${normalizedCommand} not found in PATH`
+  };
 }
 
 function buildInstallationStatus(provider, command, installed, resolvedPath, reason, cacheHit = false) {

package/server/routes/projects.js

@@ -1,18 +1,11 @@
 import express from 'express';
 import { promises as fs } from 'fs';
 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();
 
-function sanitizeGitError(message, token) {
-  if (!message || !token) return message;
-  return message.replace(new RegExp(token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g'), '***');
-}
-
 // Configure allowed workspace root (defaults to user's home directory)
 export const WORKSPACES_ROOT = process.env.WORKSPACES_ROOT || os.homedir();
 
@@ -169,9 +162,6 @@ export async function validateWorkspacePath(requestedPath) {
  * Body:
  * - workspaceType: 'existing' | 'new'
  * - path: string (workspace path)
- * - githubUrl?: string (optional, for new workspaces)
- * - githubTokenId?: number (optional, ID of stored token)
- * - newGithubToken?: string (optional, one-time token)
  */
 router.post('/create-workspace', async (req, res) => {
   try {
@@ -182,6 +172,16 @@ router.post('/create-workspace', async (req, res) => {
       return res.status(400).json({ error: 'workspaceType and path are required' });
     }
 
+    if (
+      githubUrl !== undefined
+      || githubTokenId !== undefined
+      || newGithubToken !== undefined
+    ) {
+      return res.status(400).json({
+        error: 'GitHub-based workspace creation has been removed. Create an empty workspace or add an existing local workspace instead.'
+      });
+    }
+
     if (!['existing', 'new'].includes(workspaceType)) {
       return res.status(400).json({ error: 'workspaceType must be "existing" or "new"' });
     }
@@ -229,66 +229,6 @@ router.post('/create-workspace', async (req, res) => {
       // Create the directory if it doesn't exist
       await fs.mkdir(absolutePath, { recursive: true });
 
-      // If GitHub URL is provided, clone the repository
-      if (githubUrl) {
-        let githubToken = null;
-
-        // Get GitHub token if needed
-        if (githubTokenId) {
-          // Fetch token from database
-          const token = await getGithubTokenById(githubTokenId, req.user.id);
-          if (!token) {
-            // Clean up created directory
-            await fs.rm(absolutePath, { recursive: true, force: true });
-            return res.status(404).json({ error: 'GitHub token not found' });
-          }
-          githubToken = token.github_token;
-        } else if (newGithubToken) {
-          githubToken = newGithubToken;
-        }
-
-        // Extract repo name from URL for the clone destination
-        const normalizedUrl = githubUrl.replace(/\/+$/, '').replace(/\.git$/, '');
-        const repoName = normalizedUrl.split('/').pop() || 'repository';
-        const clonePath = path.join(absolutePath, repoName);
-
-        // Check if clone destination already exists to prevent data loss
-        try {
-          await fs.access(clonePath);
-          return res.status(409).json({
-            error: 'Directory already exists',
-            details: `The destination path "${clonePath}" already exists. Please choose a different location or remove the existing directory.`
-          });
-        } catch (err) {
-          // Directory doesn't exist, which is what we want
-        }
-
-        // Clone the repository into a subfolder
-        try {
-          await cloneGitHubRepository(githubUrl, clonePath, githubToken);
-        } catch (error) {
-          // Only clean up if clone created partial data (check if dir exists and is empty or partial)
-          try {
-            const stats = await fs.stat(clonePath);
-            if (stats.isDirectory()) {
-              await fs.rm(clonePath, { recursive: true, force: true });
-            }
-          } catch (cleanupError) {
-            // Directory doesn't exist or cleanup failed - ignore
-          }
-          throw new Error(`Failed to clone repository: ${error.message}`);
-        }
-
-        // Add the cloned repo path to the project list
-        const project = await addProjectManually(clonePath);
-
-        return res.json({
-          success: true,
-          project,
-          message: 'New workspace created and repository cloned successfully'
-        });
-      }
-
       // Add the new workspace to the project list (no clone)
       const project = await addProjectManually(absolutePath);
 
@@ -308,238 +248,4 @@ router.post('/create-workspace', async (req, res) => {
   }
 });
 
-/**
- * Helper function to get GitHub token from database
- */
-async function getGithubTokenById(tokenId, userId) {
-  const credential = githubTokensDb.getGithubTokenById(userId, tokenId);
-
-  // Return in the expected format (github_token field for compatibility)
-  if (credential) {
-    return {
-      ...credential,
-      github_token: credential.credential_value
-    };
-  }
-
-  return null;
-}
-
-/**
- * Clone repository with progress streaming (SSE)
- * GET /api/projects/clone-progress
- */
-router.get('/clone-progress', async (req, res) => {
-  const { path: workspacePath, githubUrl, githubTokenId, newGithubToken } = req.query;
-
-  res.setHeader('Content-Type', 'text/event-stream');
-  res.setHeader('Cache-Control', 'no-cache');
-  res.setHeader('Connection', 'keep-alive');
-  res.flushHeaders();
-
-  const sendEvent = (type, data) => {
-    res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
-  };
-
-  try {
-    if (!workspacePath || !githubUrl) {
-      sendEvent('error', { message: 'workspacePath and githubUrl are required' });
-      res.end();
-      return;
-    }
-
-    const validation = await validateWorkspacePath(workspacePath);
-    if (!validation.valid) {
-      sendEvent('error', { message: validation.error });
-      res.end();
-      return;
-    }
-
-    const absolutePath = validation.resolvedPath;
-
-    await fs.mkdir(absolutePath, { recursive: true });
-
-    let githubToken = null;
-    if (githubTokenId) {
-      const token = await getGithubTokenById(parseInt(githubTokenId), req.user.id);
-      if (!token) {
-        await fs.rm(absolutePath, { recursive: true, force: true });
-        sendEvent('error', { message: 'GitHub token not found' });
-        res.end();
-        return;
-      }
-      githubToken = token.github_token;
-    } else if (newGithubToken) {
-      githubToken = newGithubToken;
-    }
-
-    const normalizedUrl = githubUrl.replace(/\/+$/, '').replace(/\.git$/, '');
-    const repoName = normalizedUrl.split('/').pop() || 'repository';
-    const clonePath = path.join(absolutePath, repoName);
-
-    // Check if clone destination already exists to prevent data loss
-    try {
-      await fs.access(clonePath);
-      sendEvent('error', { message: `Directory "${repoName}" already exists. Please choose a different location or remove the existing directory.` });
-      res.end();
-      return;
-    } catch (err) {
-      // Directory doesn't exist, which is what we want
-    }
-
-    let cloneUrl = githubUrl;
-    if (githubToken) {
-      try {
-        const url = new URL(githubUrl);
-        url.username = githubToken;
-        url.password = '';
-        cloneUrl = url.toString();
-      } catch (error) {
-        // SSH URL or invalid - use as-is
-      }
-    }
-
-    sendEvent('progress', { message: `Cloning into '${repoName}'...` });
-
-    const gitProcess = spawn('git', ['clone', '--progress', cloneUrl, clonePath], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        GIT_TERMINAL_PROMPT: '0'
-      }
-    });
-
-    let lastError = '';
-
-    gitProcess.stdout.on('data', (data) => {
-      const message = data.toString().trim();
-      if (message) {
-        sendEvent('progress', { message });
-      }
-    });
-
-    gitProcess.stderr.on('data', (data) => {
-      const message = data.toString().trim();
-      lastError = message;
-      if (message) {
-        sendEvent('progress', { message });
-      }
-    });
-
-    gitProcess.on('close', async (code) => {
-      if (code === 0) {
-        try {
-          const project = await addProjectManually(clonePath);
-          sendEvent('complete', { project, message: 'Repository cloned successfully' });
-        } catch (error) {
-          sendEvent('error', { message: `Clone succeeded but failed to add project: ${error.message}` });
-        }
-      } else {
-        const sanitizedError = sanitizeGitError(lastError, githubToken);
-        let errorMessage = 'Git clone failed';
-        if (lastError.includes('Authentication failed') || lastError.includes('could not read Username')) {
-          errorMessage = 'Authentication failed. Please check your credentials.';
-        } else if (lastError.includes('Repository not found')) {
-          errorMessage = 'Repository not found. Please check the URL and ensure you have access.';
-        } else if (lastError.includes('already exists')) {
-          errorMessage = 'Directory already exists';
-        } else if (sanitizedError) {
-          errorMessage = sanitizedError;
-        }
-        try {
-          await fs.rm(clonePath, { recursive: true, force: true });
-        } catch (cleanupError) {
-          console.error('Failed to clean up after clone failure:', sanitizeGitError(cleanupError.message, githubToken));
-        }
-        sendEvent('error', { message: errorMessage });
-      }
-      res.end();
-    });
-
-    gitProcess.on('error', (error) => {
-      if (error.code === 'ENOENT') {
-        sendEvent('error', { message: 'Git is not installed or not in PATH' });
-      } else {
-        sendEvent('error', { message: error.message });
-      }
-      res.end();
-    });
-
-    req.on('close', () => {
-      gitProcess.kill();
-    });
-
-  } catch (error) {
-    sendEvent('error', { message: error.message });
-    res.end();
-  }
-});
-
-/**
- * Helper function to clone a GitHub repository
- */
-function cloneGitHubRepository(githubUrl, destinationPath, githubToken = null) {
-  return new Promise((resolve, reject) => {
-    let cloneUrl = githubUrl;
-
-    if (githubToken) {
-      try {
-        const url = new URL(githubUrl);
-        url.username = githubToken;
-        url.password = '';
-        cloneUrl = url.toString();
-      } catch (error) {
-        // SSH URL - use as-is
-      }
-    }
-
-    const gitProcess = spawn('git', ['clone', '--progress', cloneUrl, destinationPath], {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      env: {
-        ...process.env,
-        GIT_TERMINAL_PROMPT: '0'
-      }
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    gitProcess.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    gitProcess.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    gitProcess.on('close', (code) => {
-      if (code === 0) {
-        resolve({ stdout, stderr });
-      } else {
-        let errorMessage = 'Git clone failed';
-
-        if (stderr.includes('Authentication failed') || stderr.includes('could not read Username')) {
-          errorMessage = 'Authentication failed. Please check your GitHub token.';
-        } else if (stderr.includes('Repository not found')) {
-          errorMessage = 'Repository not found. Please check the URL and ensure you have access.';
-        } else if (stderr.includes('already exists')) {
-          errorMessage = 'Directory already exists';
-        } else if (stderr) {
-          errorMessage = stderr;
-        }
-
-        reject(new Error(errorMessage));
-      }
-    });
-
-    gitProcess.on('error', (error) => {
-      if (error.code === 'ENOENT') {
-        reject(new Error('Git is not installed or not in PATH'));
-      } else {
-        reject(error);
-      }
-    });
-  });
-}
-
 export default router;

package/server/routes/settings.js

@@ -117,6 +117,10 @@ router.post('/credentials', async (req, res) => {
       return res.status(400).json({ error: 'Credential value is required' });
     }
 
+    if (credentialType.trim() === 'github_token') {
+      return res.status(400).json({ error: 'GitHub tokens are no longer supported.' });
+    }
+
     const result = credentialsDb.createCredential(
       req.user.id,
       credentialName.trim(),

package/server/routes/user.js

@@ -1,106 +1,4 @@
 import express from 'express';
-import { userDb } from '../database/db.js';
-import { authenticateToken } from '../middleware/auth.js';
-import { getSystemGitConfig } from '../utils/gitConfig.js';
-import { exec } from 'child_process';
-import { promisify } from 'util';
-
-const execAsync = promisify(exec);
 const router = express.Router();
 
-router.get('/git-config', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    let gitConfig = userDb.getGitConfig(userId);
-
-    // If database is empty, try to get from system git config
-    if (!gitConfig || (!gitConfig.git_name && !gitConfig.git_email)) {
-      const systemConfig = await getSystemGitConfig();
-
-      // If system has values, save them to database for this user
-      if (systemConfig.git_name || systemConfig.git_email) {
-        userDb.updateGitConfig(userId, systemConfig.git_name, systemConfig.git_email);
-        gitConfig = systemConfig;
-        console.log(`Auto-populated git config from system for user ${userId}: ${systemConfig.git_name} <${systemConfig.git_email}>`);
-      }
-    }
-
-    res.json({
-      success: true,
-      gitName: gitConfig?.git_name || null,
-      gitEmail: gitConfig?.git_email || null
-    });
-  } catch (error) {
-    console.error('Error getting git config:', error);
-    res.status(500).json({ error: 'Failed to get git configuration' });
-  }
-});
-
-// Apply git config globally via git config --global
-router.post('/git-config', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    const { gitName, gitEmail } = req.body;
-
-    if (!gitName || !gitEmail) {
-      return res.status(400).json({ error: 'Git name and email are required' });
-    }
-
-    // Validate email format
-    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-    if (!emailRegex.test(gitEmail)) {
-      return res.status(400).json({ error: 'Invalid email format' });
-    }
-
-    userDb.updateGitConfig(userId, gitName, gitEmail);
-
-    try {
-      await execAsync(`git config --global user.name "${gitName.replace(/"/g, '\\"')}"`);
-      await execAsync(`git config --global user.email "${gitEmail.replace(/"/g, '\\"')}"`);
-      console.log(`Applied git config globally: ${gitName} <${gitEmail}>`);
-    } catch (gitError) {
-      console.error('Error applying git config:', gitError);
-    }
-
-    res.json({
-      success: true,
-      gitName,
-      gitEmail
-    });
-  } catch (error) {
-    console.error('Error updating git config:', error);
-    res.status(500).json({ error: 'Failed to update git configuration' });
-  }
-});
-
-router.post('/complete-onboarding', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    userDb.completeOnboarding(userId);
-
-    res.json({
-      success: true,
-      message: 'Onboarding completed successfully'
-    });
-  } catch (error) {
-    console.error('Error completing onboarding:', error);
-    res.status(500).json({ error: 'Failed to complete onboarding' });
-  }
-});
-
-router.get('/onboarding-status', authenticateToken, async (req, res) => {
-  try {
-    const userId = req.user.id;
-    const hasCompleted = userDb.hasCompletedOnboarding(userId);
-
-    res.json({
-      success: true,
-      hasCompletedOnboarding: hasCompleted
-    });
-  } catch (error) {
-    console.error('Error checking onboarding status:', error);
-    res.status(500).json({ error: 'Failed to check onboarding status' });
-  }
-});
-
 export default router;