@l4yercak3/cli 1.1.12 → 1.2.1

package/src/detectors/expo-detector.js

@@ -0,0 +1,163 @@
+/**
+ * Expo/React Native Project Detector
+ * Detects Expo and React Native projects and their configuration
+ */
+
+const fs = require('fs');
+const path = require('path');
+const BaseDetector = require('./base-detector');
+
+class ExpoDetector extends BaseDetector {
+  get name() {
+    return 'expo';
+  }
+
+  get priority() {
+    return 95; // High priority - specific framework
+  }
+
+  /**
+   * Detect if current directory is an Expo or React Native project
+   */
+  detect(projectPath = process.cwd()) {
+    const results = {
+      isExpo: false,
+      isReactNative: false,
+      expoVersion: null,
+      reactNativeVersion: null,
+      hasTypeScript: false,
+      routerType: null, // 'expo-router' or 'react-navigation' or null
+      sdkVersion: null,
+      config: null,
+    };
+
+    // Check for package.json
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+      return {
+        detected: false,
+        confidence: 0,
+        metadata: {},
+      };
+    }
+
+    try {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+      const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies,
+      };
+
+      // Check for Expo
+      if (dependencies.expo) {
+        results.isExpo = true;
+        results.expoVersion = dependencies.expo;
+      }
+
+      // Check for React Native (with or without Expo)
+      if (dependencies['react-native']) {
+        results.isReactNative = true;
+        results.reactNativeVersion = dependencies['react-native'];
+      }
+
+      // If neither, not a React Native project
+      if (!results.isExpo && !results.isReactNative) {
+        return {
+          detected: false,
+          confidence: 0,
+          metadata: {},
+        };
+      }
+
+      // Check for TypeScript
+      if (dependencies.typescript || fs.existsSync(path.join(projectPath, 'tsconfig.json'))) {
+        results.hasTypeScript = true;
+      }
+
+      // Detect router type
+      if (dependencies['expo-router']) {
+        results.routerType = 'expo-router';
+      } else if (dependencies['@react-navigation/native']) {
+        results.routerType = 'react-navigation';
+      }
+
+      // Check for app.json or app.config.js (Expo config)
+      const appJsonPath = path.join(projectPath, 'app.json');
+      const appConfigJsPath = path.join(projectPath, 'app.config.js');
+      const appConfigTsPath = path.join(projectPath, 'app.config.ts');
+
+      if (fs.existsSync(appJsonPath)) {
+        try {
+          const appJson = JSON.parse(fs.readFileSync(appJsonPath, 'utf8'));
+          results.config = 'app.json';
+          if (appJson.expo?.sdkVersion) {
+            results.sdkVersion = appJson.expo.sdkVersion;
+          }
+        } catch (error) {
+          // Could not parse app.json
+        }
+      } else if (fs.existsSync(appConfigJsPath)) {
+        results.config = 'app.config.js';
+      } else if (fs.existsSync(appConfigTsPath)) {
+        results.config = 'app.config.ts';
+      }
+
+      // Determine confidence based on what we found
+      let confidence = 0.7; // Base confidence for React Native
+      if (results.isExpo) {
+        confidence = 0.9; // Higher for Expo
+        if (results.config) {
+          confidence = 0.95; // Even higher with config file
+        }
+      }
+
+      return {
+        detected: true,
+        confidence,
+        metadata: {
+          isExpo: results.isExpo,
+          expoVersion: results.expoVersion,
+          reactNativeVersion: results.reactNativeVersion,
+          hasTypeScript: results.hasTypeScript,
+          routerType: results.routerType,
+          sdkVersion: results.sdkVersion,
+          config: results.config,
+        },
+      };
+    } catch (error) {
+      // Error reading package.json
+      return {
+        detected: false,
+        confidence: 0,
+        metadata: {},
+      };
+    }
+  }
+
+  /**
+   * Get supported features for Expo/React Native
+   */
+  getSupportedFeatures() {
+    return {
+      oauth: true,      // OAuth via expo-auth-session or similar
+      stripe: true,     // Stripe via @stripe/stripe-react-native
+      crm: true,        // CRM API access
+      projects: true,   // Projects API access
+      invoices: true,   // Invoices API access
+    };
+  }
+
+  /**
+   * Get available generators for Expo/React Native
+   */
+  getAvailableGenerators() {
+    return [
+      'api-client',    // TypeScript API client
+      'env',           // Environment variables
+      'oauth-guide',   // OAuth setup guide for mobile
+      // Future: 'expo-auth', 'stripe-mobile'
+    ];
+  }
+}
+
+module.exports = new ExpoDetector();

package/src/detectors/registry.js

@@ -6,6 +6,7 @@
  */
 
 const nextJsDetector = require('./nextjs-detector');
+const expoDetector = require('./expo-detector');
 // Future detectors will be added here:
 // const reactDetector = require('./react-detector');
 // const vueDetector = require('./vue-detector');
@@ -16,6 +17,7 @@ const nextJsDetector = require('./nextjs-detector');
  */
 const detectors = [
   nextJsDetector,
+  expoDetector,
   // Future: reactDetector, vueDetector, etc.
 ];
 

package/src/mcp/auth.js

@@ -0,0 +1,127 @@
+/**
+ * MCP Server Authentication Layer
+ *
+ * Reads CLI session from ~/.l4yercak3/config.json and validates with backend.
+ * Provides auth context for tool execution.
+ *
+ * @module mcp/auth
+ */
+
+const configManager = require('../config/config-manager');
+const backendClient = require('../api/backend-client');
+
+/**
+ * @typedef {Object} AuthContext
+ * @property {string} userId - The authenticated user's ID
+ * @property {string} organizationId - Current organization ID
+ * @property {string} organizationName - Current organization name
+ * @property {string} sessionToken - The CLI session token
+ * @property {string[]} permissions - User's permissions in the organization
+ */
+
+/**
+ * Get authentication context from CLI session
+ * Returns null if not authenticated or session expired
+ *
+ * @returns {Promise<AuthContext|null>}
+ */
+async function getAuthContext() {
+  // Check if session exists locally
+  if (!configManager.isLoggedIn()) {
+    return null;
+  }
+
+  const session = configManager.getSession();
+  if (!session || !session.token) {
+    return null;
+  }
+
+  // Check if session is expired locally
+  if (session.expiresAt && session.expiresAt < Date.now()) {
+    return null;
+  }
+
+  try {
+    // Validate session with backend
+    const validation = await backendClient.validateSession();
+
+    if (!validation || !validation.valid) {
+      return null;
+    }
+
+    // Build auth context
+    return {
+      userId: validation.userId || session.userId,
+      organizationId: validation.organizationId || session.organizationId,
+      organizationName: validation.organizationName || session.organizationName || 'Unknown',
+      sessionToken: session.token,
+      email: validation.email || session.email,
+      permissions: validation.permissions || [],
+    };
+  } catch (error) {
+    // Log error to stderr (stdout is for MCP protocol)
+    console.error('[L4YERCAK3 MCP] Auth validation error:', error.message);
+    return null;
+  }
+}
+
+/**
+ * Require authentication for a tool
+ * Throws if not authenticated
+ *
+ * @param {AuthContext|null} authContext
+ * @returns {AuthContext}
+ * @throws {Error} If not authenticated
+ */
+function requireAuth(authContext) {
+  if (!authContext) {
+    throw new Error(
+      'Not authenticated with L4YERCAK3. Please run "l4yercak3 login" first.'
+    );
+  }
+  return authContext;
+}
+
+/**
+ * Check if user has a specific permission
+ *
+ * @param {AuthContext} authContext
+ * @param {string} permission
+ * @returns {boolean}
+ */
+function hasPermission(authContext, permission) {
+  if (!authContext || !authContext.permissions) {
+    return false;
+  }
+
+  // Check for wildcard permission
+  if (authContext.permissions.includes('*')) {
+    return true;
+  }
+
+  return authContext.permissions.includes(permission);
+}
+
+/**
+ * Require a specific permission
+ *
+ * @param {AuthContext} authContext
+ * @param {string} permission
+ * @throws {Error} If permission not granted
+ */
+function requirePermission(authContext, permission) {
+  requireAuth(authContext);
+
+  if (!hasPermission(authContext, permission)) {
+    throw new Error(
+      `Permission denied: ${permission} required. Contact your organization admin.`
+    );
+  }
+}
+
+module.exports = {
+  getAuthContext,
+  requireAuth,
+  hasPermission,
+  requirePermission,
+};