@symbo.ls/sdk 3.1.2 → 3.2.3

package/src/services/CoreService.js

@@ -7,7 +7,7 @@ export class CoreService extends BaseService {
     super(config)
     this._client = null
     this._initialized = false
-    this._baseUrl = null
+    this._apiUrl = null
     this._tokenManager = null
   }
 
@@ -16,15 +16,15 @@ export class CoreService extends BaseService {
       const { appKey, authToken } = context || this._context
 
       // Get base URL from environment config
-      this._baseUrl = environment.apiUrl || environment.baseUrl
+      this._apiUrl = environment.apiUrl
 
-      if (!this._baseUrl) {
+      if (!this._apiUrl) {
         throw new Error('Core service base URL not configured')
       }
 
       // Initialize token manager
       this._tokenManager = getTokenManager({
-        apiUrl: this._baseUrl,
+        apiUrl: this._apiUrl,
         onTokenRefresh: (tokens) => {
           // Update context with new token
           this.updateContext({ authToken: tokens.accessToken })
@@ -38,15 +38,14 @@ export class CoreService extends BaseService {
         }
       })
 
-      // If we have an authToken, set it in the token manager
-      if (authToken) {
+      if (authToken && !this._tokenManager.hasTokens()) {
         this._tokenManager.setTokens({ access_token: authToken })
       }
 
       // Store masked configuration info
       this._info = {
         config: {
-          baseUrl: this._baseUrl,
+          apiUrl: this._apiUrl,
           appKey: appKey ? `${appKey.substr(0, 4)}...${appKey.substr(-4)}` : null,
           hasToken: Boolean(authToken)
         }
@@ -66,11 +65,15 @@ export class CoreService extends BaseService {
       'register',
       'login',
       'googleAuth',
+      'googleAuthCallback',
       'githubAuth',
       'requestPasswordReset',
       'confirmPasswordReset',
       'confirmRegistration',
-      'verifyEmail'
+      'verifyEmail',
+      'listPublicProjects',
+      'getPublicProject',
+      'getHealthStatus'
     ])
     return !noInitMethods.has(methodName)
   }
@@ -106,12 +109,31 @@ export class CoreService extends BaseService {
     }
   }
 
+  // Helper method to check if user is authenticated
+  isAuthenticated () {
+    if (!this._tokenManager) {
+      return false
+    }
+    return this._tokenManager.hasTokens()
+  }
+
+  // Helper method to check if user has valid tokens
+  hasValidTokens () {
+    if (!this._tokenManager) {
+      return false
+    }
+    return this._tokenManager.hasTokens() && this._tokenManager.isAccessTokenValid()
+  }
+
   // Helper method to make HTTP requests
   async _request (endpoint, options = {}) {
-    const url = `${this._baseUrl}/core${endpoint}`
+    const url = `${this._apiUrl}/core${endpoint}`
+
+    const defaultHeaders = {}
 
-    const defaultHeaders = {
-      'Content-Type': 'application/json'
+    // Only set Content-Type for JSON requests, not for FormData
+    if (!(options.body instanceof FormData)) {
+      defaultHeaders['Content-Type'] = 'application/json'
     }
 
     // Use TokenManager for automatic token management
@@ -119,16 +141,11 @@ export class CoreService extends BaseService {
       try {
         // Ensure we have a valid token (will refresh if needed)
         const validToken = await this._tokenManager.ensureValidToken()
-        console.log(`[CoreService] Token check for ${options.methodName}:`, {
-          hasValidToken: Boolean(validToken),
-          tokenPreview: validToken ? `${validToken.substring(0, 20)}...` : null
-        })
 
         if (validToken) {
           const authHeader = this._tokenManager.getAuthHeader()
           if (authHeader) {
             defaultHeaders.Authorization = authHeader
-            console.log(`[CoreService] Added auth header for ${options.methodName}`)
           }
         }
       } catch (error) {
@@ -139,7 +156,6 @@ export class CoreService extends BaseService {
       const { authToken } = this._context
       if (authToken) {
         defaultHeaders.Authorization = `Bearer ${authToken}`
-        console.log(`[CoreService] Using context token for ${options.methodName}`)
       }
     }
 
@@ -172,11 +188,15 @@ export class CoreService extends BaseService {
 
   async register (userData) {
     try {
-      return await this._request('/auth/register', {
+      const response = await this._request('/auth/register', {
         method: 'POST',
         body: JSON.stringify(userData),
         methodName: 'register'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Registration failed: ${error.message}`)
     }
@@ -209,7 +229,10 @@ export class CoreService extends BaseService {
         this.updateContext({ authToken: tokens.accessToken })
       }
 
-      return response
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Login failed: ${error.message}`)
     }
@@ -242,11 +265,15 @@ export class CoreService extends BaseService {
 
   async refreshToken (refreshToken) {
     try {
-      return await this._request('/auth/refresh', {
+      const response = await this._request('/auth/refresh', {
         method: 'POST',
         body: JSON.stringify({ refreshToken }),
         methodName: 'refreshToken'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Token refresh failed: ${error.message}`)
     }
@@ -279,7 +306,10 @@ export class CoreService extends BaseService {
         this.updateContext({ authToken: tokens.accessToken })
       }
 
-      return response
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Google auth failed: ${error.message}`)
     }
@@ -312,19 +342,62 @@ export class CoreService extends BaseService {
         this.updateContext({ authToken: tokens.accessToken })
       }
 
-      return response
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`GitHub auth failed: ${error.message}`)
     }
   }
 
+  async googleAuthCallback (code, redirectUri) {
+    try {
+      const response = await this._request('/auth/google/callback', {
+        method: 'POST',
+        body: JSON.stringify({ code, redirectUri }),
+        methodName: 'googleAuthCallback'
+      })
+
+      // Handle new response format: response.data.tokens
+      if (response.success && response.data && response.data.tokens) {
+        const { tokens } = response.data
+        const tokenData = {
+          access_token: tokens.accessToken,
+          refresh_token: tokens.refreshToken,
+          expires_in: tokens.accessTokenExp?.expiresIn,
+          token_type: 'Bearer'
+        }
+
+        // Set tokens in TokenManager
+        if (this._tokenManager) {
+          this._tokenManager.setTokens(tokenData)
+        }
+
+        // Update context for backward compatibility
+        this.updateContext({ authToken: tokens.accessToken })
+      }
+
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Google auth callback failed: ${error.message}`)
+    }
+  }
+
   async requestPasswordReset (email) {
     try {
-      return await this._request('/auth/request-password-reset', {
+      const response = await this._request('/auth/request-password-reset', {
         method: 'POST',
         body: JSON.stringify({ email }),
         methodName: 'requestPasswordReset'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Password reset request failed: ${error.message}`)
     }
@@ -332,11 +405,15 @@ export class CoreService extends BaseService {
 
   async confirmPasswordReset (token, password) {
     try {
-      return await this._request('/auth/reset-password-confirm', {
+      const response = await this._request('/auth/reset-password-confirm', {
         method: 'POST',
         body: JSON.stringify({ token, password }),
         methodName: 'confirmPasswordReset'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Password reset confirmation failed: ${error.message}`)
     }
@@ -344,11 +421,15 @@ export class CoreService extends BaseService {
 
   async confirmRegistration (token) {
     try {
-      return await this._request('/auth/register-confirmation', {
+      const response = await this._request('/auth/register-confirmation', {
         method: 'POST',
         body: JSON.stringify({ token }),
         methodName: 'confirmRegistration'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Registration confirmation failed: ${error.message}`)
     }
@@ -357,10 +438,14 @@ export class CoreService extends BaseService {
   async requestPasswordChange () {
     this._requireReady('requestPasswordChange')
     try {
-      return await this._request('/auth/request-password-change', {
+      const response = await this._request('/auth/request-password-change', {
         method: 'POST',
         methodName: 'requestPasswordChange'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Password change request failed: ${error.message}`)
     }
@@ -369,11 +454,15 @@ export class CoreService extends BaseService {
   async confirmPasswordChange (currentPassword, newPassword, code) {
     this._requireReady('confirmPasswordChange')
     try {
-      return await this._request('/auth/confirm-password-change', {
+      const response = await this._request('/auth/confirm-password-change', {
         method: 'POST',
         body: JSON.stringify({ currentPassword, newPassword, code }),
         methodName: 'confirmPasswordChange'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Password change confirmation failed: ${error.message}`)
     }
@@ -382,10 +471,14 @@ export class CoreService extends BaseService {
   async getMe () {
     this._requireReady('getMe')
     try {
-      return await this._request('/auth/me', {
+      const response = await this._request('/auth/me', {
         method: 'GET',
         methodName: 'getMe'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get user profile: ${error.message}`)
     }
@@ -418,40 +511,70 @@ export class CoreService extends BaseService {
         try {
           await this._tokenManager.ensureValidToken()
         } catch (error) {
-          // If refresh fails, clear tokens and return empty state
-          this._tokenManager.clearTokens()
+          console.warn('[CoreService] Token refresh failed:', error.message)
+          // Only clear tokens if it's definitely an auth error, not a network error
+          if (error.message.includes('401') || error.message.includes('403') ||
+              error.message.includes('invalid') || error.message.includes('expired')) {
+            this._tokenManager.clearTokens()
+            return {
+              userId: false,
+              authToken: false,
+              error: `Authentication failed: ${error.message}`
+            }
+          }
+          // For network errors, keep tokens and return what we have
           return {
             userId: false,
-            authToken: false,
-            error: `Token refresh failed: ${error.message}`
+            authToken: this._tokenManager.getAccessToken(),
+            error: `Network error during token refresh: ${error.message}`,
+            hasTokens: true
           }
         }
       }
 
+      // Check if we have a valid token now
+      const currentAccessToken = this._tokenManager.getAccessToken()
+      if (!currentAccessToken) {
+        return {
+          userId: false,
+          authToken: false
+        }
+      }
+
       // Get current user data if we have valid tokens
+      // Be more lenient with API failures - don't immediately clear tokens
       try {
         const currentUser = await this.getMe()
-        const userProjects = await this.getUserProjects()
 
         return {
-          userId: currentUser.data.id,
-          authToken: this._tokenManager.getAccessToken(),
-          user: {
-            ...currentUser.data,
-            projects: userProjects?.data || []
-          },
+          userId: currentUser.user.id,
+          authToken: currentAccessToken,
+          ...currentUser,
           error: null
         }
       } catch (error) {
-        // If API calls fail, clear invalid tokens
-        this._tokenManager.clearTokens()
+        console.warn('[CoreService] Failed to get user data:', error.message)
+
+        // Only clear tokens if it's an auth error (401, 403), not network errors
+        if (error.message.includes('401') || error.message.includes('403')) {
+          this._tokenManager.clearTokens()
+          return {
+            userId: false,
+            authToken: false,
+            error: `Authentication failed: ${error.message}`
+          }
+        }
+
+        // For other errors (network, 500, etc.), keep tokens but return minimal state
         return {
           userId: false,
-          authToken: false,
-          error: `Failed to get user data: ${error.message}`
+          authToken: currentAccessToken,
+          error: `Failed to get user data: ${error.message}`,
+          hasTokens: true
         }
       }
     } catch (error) {
+      console.error('[CoreService] Unexpected error in getStoredAuthState:', error)
       return {
         userId: false,
         authToken: false,
@@ -465,10 +588,14 @@ export class CoreService extends BaseService {
   async getUserProfile () {
     this._requireReady('getUserProfile')
     try {
-      return await this._request('/users/profile', {
+      const response = await this._request('/users/profile', {
         method: 'GET',
         methodName: 'getUserProfile'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get user profile: ${error.message}`)
     }
@@ -477,11 +604,15 @@ export class CoreService extends BaseService {
   async updateUserProfile (profileData) {
     this._requireReady('updateUserProfile')
     try {
-      return await this._request('/users/profile', {
+      const response = await this._request('/users/profile', {
         method: 'PATCH',
         body: JSON.stringify(profileData),
         methodName: 'updateUserProfile'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update user profile: ${error.message}`)
     }
@@ -490,10 +621,17 @@ export class CoreService extends BaseService {
   async getUserProjects () {
     this._requireReady('getUserProjects')
     try {
-      return await this._request('/users/projects', {
+      const response = await this._request('/users/projects', {
         method: 'GET',
         methodName: 'getUserProjects'
       })
+      if (response.success) {
+        return response.data.map(project => ({
+          ...project,
+          ...(project.icon && { icon: { src: `${this._apiUrl}/core/files/public/${project.icon.id}/download`, ...project.icon } })
+        }))
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get user projects: ${error.message}`)
     }
@@ -505,10 +643,14 @@ export class CoreService extends BaseService {
       throw new Error('User ID is required')
     }
     try {
-      return await this._request(`/users/${userId}`, {
+      const response = await this._request(`/users/${userId}`, {
         method: 'GET',
         methodName: 'getUser'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get user: ${error.message}`)
     }
@@ -520,13 +662,17 @@ export class CoreService extends BaseService {
       throw new Error('Email is required')
     }
     try {
-      return await this._request('/auth/user', {
+      const response = await this._request('/auth/user', {
         method: 'GET',
         headers: {
           'X-User-Email': email
         },
         methodName: 'getUserByEmail'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get user by email: ${error.message}`)
     }
@@ -537,53 +683,148 @@ export class CoreService extends BaseService {
   async createProject (projectData) {
     this._requireReady('createProject')
     try {
-      return await this._request('/projects', {
+      const response = await this._request('/projects', {
         method: 'POST',
         body: JSON.stringify(projectData),
         methodName: 'createProject'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to create project: ${error.message}`)
     }
   }
 
-  async getProjects () {
+  async getProjects (params = {}) {
     this._requireReady('getProjects')
     try {
-      return await this._request('/projects', {
+      const queryParams = new URLSearchParams()
+
+      // Add query parameters
+      Object.keys(params).forEach(key => {
+        if (params[key] != null) {
+          queryParams.append(key, params[key])
+        }
+      })
+
+      const queryString = queryParams.toString()
+      const url = `/projects${queryString ? `?${queryString}` : ''}`
+
+      const response = await this._request(url, {
         method: 'GET',
         methodName: 'getProjects'
       })
+      if (response.success) {
+        return response
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get projects: ${error.message}`)
     }
   }
 
+  /**
+   * Alias for getProjects for consistency with API naming
+   */
+  async listProjects (params = {}) {
+    return await this.getProjects(params)
+  }
+
+  /**
+   * List only public projects (no authentication required)
+   */
+  async listPublicProjects (params = {}) {
+    try {
+      const queryParams = new URLSearchParams()
+
+      // Add query parameters
+      Object.keys(params).forEach(key => {
+        if (params[key] != null) {
+          queryParams.append(key, params[key])
+        }
+      })
+
+      const queryString = queryParams.toString()
+      const url = `/projects/public${queryString ? `?${queryString}` : ''}`
+
+      const response = await this._request(url, {
+        method: 'GET',
+        methodName: 'listPublicProjects'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to list public projects: ${error.message}`)
+    }
+  }
+
   async getProject (projectId) {
     this._requireReady('getProject')
     if (!projectId) {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}`, {
+      const response = await this._request(`/projects/${projectId}`, {
         method: 'GET',
         methodName: 'getProject'
       })
+      if (response.success) {
+        const iconSrc = response.data.icon ? `${this._apiUrl}/core/files/public/${response.data.icon.id}/download` : null
+        return {
+          ...response.data,
+          icon: { src: iconSrc, ...response.data.icon }
+        }
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project: ${error.message}`)
     }
   }
 
+  /**
+   * Get a public project by ID (no authentication required)
+   * Corresponds to router.get('/public/:projectId', ProjectController.getPublicProject)
+   */
+  async getPublicProject (projectId) {
+    if (!projectId) {
+      throw new Error('Project ID is required')
+    }
+    try {
+      const response = await this._request(`/projects/public/${projectId}`, {
+        method: 'GET',
+        methodName: 'getPublicProject'
+      })
+      if (response.success) {
+        const iconSrc = response.data.icon ? `${this._apiUrl}/core/files/public/${response.data.icon.id}/download` : null
+        return {
+          ...response.data,
+          icon: { src: iconSrc, ...response.data.icon }
+        }
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get public project: ${error.message}`)
+    }
+  }
+
   async getProjectByKey (key) {
     this._requireReady('getProjectByKey')
     if (!key) {
       throw new Error('Project key is required')
     }
     try {
-      return await this._request(`/projects/check-key/${key}`, {
+      const response = await this._request(`/projects/check-key/${key}`, {
         method: 'GET',
         methodName: 'getProjectByKey'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project by key: ${error.message}`)
     }
@@ -595,11 +836,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}`, {
+      const response = await this._request(`/projects/${projectId}`, {
         method: 'PATCH',
         body: JSON.stringify(data),
         methodName: 'updateProject'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project: ${error.message}`)
     }
@@ -611,11 +856,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/components`, {
+      const response = await this._request(`/projects/${projectId}/components`, {
         method: 'PATCH',
         body: JSON.stringify({ components }),
         methodName: 'updateProjectComponents'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project components: ${error.message}`)
     }
@@ -627,11 +876,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/settings`, {
+      const response = await this._request(`/projects/${projectId}/settings`, {
         method: 'PATCH',
         body: JSON.stringify({ settings }),
         methodName: 'updateProjectSettings'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project settings: ${error.message}`)
     }
@@ -643,11 +896,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}`, {
+      const response = await this._request(`/projects/${projectId}`, {
         method: 'PATCH',
         body: JSON.stringify({ name }),
         methodName: 'updateProjectName'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project name: ${error.message}`)
     }
@@ -659,27 +916,35 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/tier`, {
+      const response = await this._request(`/projects/${projectId}/tier`, {
         method: 'PATCH',
         body: JSON.stringify({ tier: pkg }),
         methodName: 'updateProjectPackage'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project package: ${error.message}`)
     }
   }
 
-  async duplicateProject (projectId, newName, newKey) {
+  async duplicateProject (projectId, newName, newKey, targetUserId) {
     this._requireReady('duplicateProject')
     if (!projectId) {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/duplicate`, {
+      const response = await this._request(`/projects/${projectId}/duplicate`, {
         method: 'POST',
-        body: JSON.stringify({ name: newName, key: newKey }),
+        body: JSON.stringify({ name: newName, key: newKey, targetUserId }),
         methodName: 'duplicateProject'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to duplicate project: ${error.message}`)
     }
@@ -691,10 +956,14 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}`, {
+      const response = await this._request(`/projects/${projectId}`, {
         method: 'DELETE',
         methodName: 'removeProject'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to remove project: ${error.message}`)
     }
@@ -706,10 +975,14 @@ export class CoreService extends BaseService {
       throw new Error('Project key is required')
     }
     try {
-      return await this._request(`/projects/check-key/${key}`, {
+      const response = await this._request(`/projects/check-key/${key}`, {
         method: 'GET',
         methodName: 'checkProjectKeyAvailability'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to check project key availability: ${error.message}`)
     }
@@ -723,42 +996,73 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/members`, {
+      const response = await this._request(`/projects/${projectId}/members`, {
         method: 'GET',
         methodName: 'getProjectMembers'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project members: ${error.message}`)
     }
   }
 
-  async inviteMember (projectId, email, message, role = 'guest') {
+  async inviteMember (projectId, email, role = 'guest', options = {}) {
     this._requireReady('inviteMember')
-    if (!projectId || !email) {
-      throw new Error('Project ID and email are required')
+    if (!projectId || !email || !role) {
+      throw new Error('Project ID, email, and role are required')
     }
+
+    const { name, callbackUrl } = options
+
+        // Default callbackUrl if not provided
+    const defaultCallbackUrl = typeof window === 'undefined'
+      ? 'https://app.symbols.com/accept-invite'
+      : `${window.location.origin}/accept-invite`
+
     try {
-      return await this._request(`/projects/${projectId}/invite`, {
+      const requestBody = {
+        email,
+        role,
+        callbackUrl: callbackUrl || defaultCallbackUrl
+      }
+
+      // Add optional name if provided
+      if (name) {
+        requestBody.name = name
+      }
+
+      const response = await this._request(`/projects/${projectId}/invite`, {
         method: 'POST',
-        body: JSON.stringify({ email, role, message }),
+        body: JSON.stringify(requestBody),
         methodName: 'inviteMember'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to invite member: ${error.message}`)
     }
   }
 
-  async acceptInvite (projectId, token) {
+  async acceptInvite (token) {
     this._requireReady('acceptInvite')
-    if (!projectId || !token) {
-      throw new Error('Project ID and token are required')
+    if (!token) {
+      throw new Error('Invitation token is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/accept-invite`, {
+      const response = await this._request('/projects/accept-invite', {
         method: 'POST',
         body: JSON.stringify({ token }),
         methodName: 'acceptInvite'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to accept invite: ${error.message}`)
     }
@@ -770,11 +1074,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID, member ID, and role are required')
     }
     try {
-      return await this._request(`/projects/${projectId}/members/${memberId}`, {
+      const response = await this._request(`/projects/${projectId}/members/${memberId}`, {
         method: 'PATCH',
         body: JSON.stringify({ role }),
         methodName: 'updateMemberRole'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update member role: ${error.message}`)
     }
@@ -786,10 +1094,14 @@ export class CoreService extends BaseService {
       throw new Error('Project ID and member ID are required')
     }
     try {
-      return await this._request(`/projects/${projectId}/members/${memberId}`, {
+      const response = await this._request(`/projects/${projectId}/members/${memberId}`, {
         method: 'DELETE',
         methodName: 'removeMember'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to remove member: ${error.message}`)
     }
@@ -801,10 +1113,14 @@ export class CoreService extends BaseService {
     this._requireReady('getAvailableLibraries')
     const queryParams = new URLSearchParams(params).toString()
     try {
-      return await this._request(`/projects/libraries/available?${queryParams}`, {
+      const response = await this._request(`/projects/libraries/available?${queryParams}`, {
         method: 'GET',
         methodName: 'getAvailableLibraries'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get available libraries: ${error.message}`)
     }
@@ -816,10 +1132,14 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/projects/${projectId}/libraries`, {
+      const response = await this._request(`/projects/${projectId}/libraries`, {
         method: 'GET',
         methodName: 'getProjectLibraries'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project libraries: ${error.message}`)
     }
@@ -831,11 +1151,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID and library IDs are required')
     }
     try {
-      return await this._request(`/projects/${projectId}/libraries`, {
+      const response = await this._request(`/projects/${projectId}/libraries`, {
         method: 'POST',
         body: JSON.stringify({ libraryIds }),
         methodName: 'addProjectLibraries'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to add project libraries: ${error.message}`)
     }
@@ -847,11 +1171,15 @@ export class CoreService extends BaseService {
       throw new Error('Project ID and library IDs are required')
     }
     try {
-      return await this._request(`/projects/${projectId}/libraries`, {
+      const response = await this._request(`/projects/${projectId}/libraries`, {
         method: 'DELETE',
         body: JSON.stringify({ libraryIds }),
         methodName: 'removeProjectLibraries'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to remove project libraries: ${error.message}`)
     }
@@ -868,19 +1196,30 @@ export class CoreService extends BaseService {
     const formData = new FormData()
     formData.append('file', file)
 
-    // Add optional parameters
+    // Add optional parameters only if they exist
     if (options.projectId) {formData.append('projectId', options.projectId)}
     if (options.tags) {formData.append('tags', JSON.stringify(options.tags))}
-    if (options.visibility) {formData.append('visibility', options.visibility)}
+    if (options.visibility) {formData.append('visibility', options.visibility || 'public')}
     if (options.metadata) {formData.append('metadata', JSON.stringify(options.metadata))}
 
     try {
-      return await this._request('/files/upload', {
+      const response = await this._request('/files/upload', {
         method: 'POST',
         body: formData,
         headers: {}, // Let browser set Content-Type for FormData
         methodName: 'uploadFile'
       })
+
+      if (!response.success) {
+        throw new Error(response.message)
+      }
+
+      return {
+        id: response.data.id,
+        src: `${this._apiUrl}/core/files/public/${response.data.id}/download`,
+        success: true,
+        message: response.message
+      }
     } catch (error) {
       throw new Error(`File upload failed: ${error.message}`)
     }
@@ -897,12 +1236,16 @@ export class CoreService extends BaseService {
     formData.append('projectId', projectId)
 
     try {
-      return await this._request('/files/upload-project-icon', {
+      const response = await this._request('/files/upload-project-icon', {
         method: 'POST',
         body: formData,
         headers: {}, // Let browser set Content-Type for FormData
         methodName: 'updateProjectIcon'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to update project icon: ${error.message}`)
     }
@@ -925,7 +1268,7 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request('/payments/checkout', {
+      const response = await this._request('/payments/checkout', {
         method: 'POST',
         body: JSON.stringify({
           projectId,
@@ -936,6 +1279,10 @@ export class CoreService extends BaseService {
         }),
         methodName: 'checkout'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to checkout: ${error.message}`)
     }
@@ -947,10 +1294,14 @@ export class CoreService extends BaseService {
       throw new Error('Project ID is required')
     }
     try {
-      return await this._request(`/payments/subscription/${projectId}`, {
+      const response = await this._request(`/payments/subscription/${projectId}`, {
         method: 'GET',
         methodName: 'getSubscriptionStatus'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get subscription status: ${error.message}`)
     }
@@ -964,11 +1315,15 @@ export class CoreService extends BaseService {
       throw new Error('Domain is required')
     }
     try {
-      return await this._request('/dns/records', {
+      const response = await this._request('/dns/records', {
         method: 'POST',
         body: JSON.stringify({ domain, ...options }),
         methodName: 'createDnsRecord'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to create DNS record: ${error.message}`)
     }
@@ -980,10 +1335,14 @@ export class CoreService extends BaseService {
       throw new Error('Domain is required')
     }
     try {
-      return await this._request(`/dns/records/${domain}`, {
+      const response = await this._request(`/dns/records/${domain}`, {
         method: 'GET',
         methodName: 'getDnsRecord'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get DNS record: ${error.message}`)
     }
@@ -995,10 +1354,14 @@ export class CoreService extends BaseService {
       throw new Error('Domain is required')
     }
     try {
-      return await this._request(`/dns/records/${domain}`, {
+      const response = await this._request(`/dns/records/${domain}`, {
         method: 'DELETE',
         methodName: 'removeDnsRecord'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to remove DNS record: ${error.message}`)
     }
@@ -1010,7 +1373,7 @@ export class CoreService extends BaseService {
       throw new Error('Project key is required')
     }
     try {
-      return await this._request('/dns/project-domains', {
+      const response = await this._request('/dns/project-domains', {
         method: 'POST',
         body: JSON.stringify({
           projectKey,
@@ -1019,6 +1382,10 @@ export class CoreService extends BaseService {
         }),
         methodName: 'setProjectDomains'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to set project domains: ${error.message}`)
     }
@@ -1028,10 +1395,14 @@ export class CoreService extends BaseService {
 
   async getHealthStatus () {
     try {
-      return await this._request('/health', {
+      const response = await this._request('/health', {
         method: 'GET',
         methodName: 'getHealthStatus'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get health status: ${error.message}`)
     }
@@ -1070,7 +1441,10 @@ export class CoreService extends BaseService {
         methodName: 'applyProjectChanges'
       })
 
-      return response
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to apply project changes: ${error.message}`)
     }
@@ -1088,19 +1462,25 @@ export class CoreService extends BaseService {
 
     const {
       branch = 'main',
+      version = 'latest',
       includeHistory = false
     } = options
 
     const queryParams = new URLSearchParams({
       branch,
+      version,
       includeHistory: includeHistory.toString()
     }).toString()
 
     try {
-      return await this._request(`/projects/${projectId}/data?${queryParams}`, {
+      const response = await this._request(`/projects/${projectId}/data?${queryParams}`, {
         method: 'GET',
         methodName: 'getProjectData'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project data: ${error.message}`)
     }
@@ -1128,10 +1508,14 @@ export class CoreService extends BaseService {
     }).toString()
 
     try {
-      return await this._request(`/projects/${projectId}/versions?${queryParams}`, {
+      const response = await this._request(`/projects/${projectId}/versions?${queryParams}`, {
         method: 'GET',
         methodName: 'getProjectVersions'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get project versions: ${error.message}`)
     }
@@ -1157,7 +1541,7 @@ export class CoreService extends BaseService {
     } = options
 
     try {
-      return await this._request(`/projects/${projectId}/restore`, {
+      const response = await this._request(`/projects/${projectId}/restore`, {
         method: 'POST',
         body: JSON.stringify({
           version,
@@ -1167,6 +1551,10 @@ export class CoreService extends BaseService {
         }),
         methodName: 'restoreProjectVersion'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to restore project version: ${error.message}`)
     }
@@ -1277,11 +1665,15 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests`, {
         method: 'POST',
         body: JSON.stringify(pullRequestData),
         methodName: 'createPullRequest'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to create pull request: ${error.message}`)
     }
@@ -1314,10 +1706,14 @@ export class CoreService extends BaseService {
     if (target) {queryParams.append('target', target)}
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests?${queryParams.toString()}`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests?${queryParams.toString()}`, {
         method: 'GET',
         methodName: 'listPullRequests'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to list pull requests: ${error.message}`)
     }
@@ -1336,10 +1732,14 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests/${prId}`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests/${prId}`, {
         method: 'GET',
         methodName: 'getPullRequest'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get pull request: ${error.message}`)
     }
@@ -1363,11 +1763,15 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests/${prId}/review`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests/${prId}/review`, {
         method: 'POST',
         body: JSON.stringify(reviewData),
         methodName: 'reviewPullRequest'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to review pull request: ${error.message}`)
     }
@@ -1389,11 +1793,15 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests/${prId}/comment`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests/${prId}/comment`, {
         method: 'POST',
         body: JSON.stringify(commentData),
         methodName: 'addPullRequestComment'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to add pull request comment: ${error.message}`)
     }
@@ -1417,7 +1825,10 @@ export class CoreService extends BaseService {
         methodName: 'mergePullRequest'
       })
 
-      return response
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       // Handle specific merge conflict errors
       if (error.message.includes('conflicts') || error.message.includes('409')) {
@@ -1440,10 +1851,14 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/pull-requests/${prId}/diff`, {
+      const response = await this._request(`/projects/${projectId}/pull-requests/${prId}/diff`, {
         method: 'GET',
         methodName: 'getPullRequestDiff'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get pull request diff: ${error.message}`)
     }
@@ -1577,10 +1992,14 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/branches`, {
+      const response = await this._request(`/projects/${projectId}/branches`, {
         method: 'GET',
         methodName: 'listBranches'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to list branches: ${error.message}`)
     }
@@ -1601,11 +2020,15 @@ export class CoreService extends BaseService {
     const { name, source = 'main' } = branchData
 
     try {
-      return await this._request(`/projects/${projectId}/branches`, {
+      const response = await this._request(`/projects/${projectId}/branches`, {
         method: 'POST',
         body: JSON.stringify({ name, source }),
         methodName: 'createBranch'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to create branch: ${error.message}`)
     }
@@ -1627,10 +2050,14 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}`, {
+      const response = await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}`, {
         method: 'DELETE',
         methodName: 'deleteBranch'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to delete branch: ${error.message}`)
     }
@@ -1655,11 +2082,15 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/rename`, {
+      const response = await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/rename`, {
         method: 'POST',
         body: JSON.stringify({ newName }),
         methodName: 'renameBranch'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to rename branch: ${error.message}`)
     }
@@ -1668,7 +2099,7 @@ export class CoreService extends BaseService {
   /**
    * Get changes/diff for a branch compared to another version
    */
-  async getBranchChanges (projectId, branchName, options = {}) {
+  async getBranchChanges (projectId, branchName = 'main', options = {}) {
     this._requireReady('getBranchChanges')
     if (!projectId) {
       throw new Error('Project ID is required')
@@ -1688,10 +2119,14 @@ export class CoreService extends BaseService {
     const url = `/projects/${projectId}/branches/${encodeURIComponent(branchName)}/changes${queryString ? `?${queryString}` : ''}`
 
     try {
-      return await this._request(url, {
+      const response = await this._request(url, {
         method: 'GET',
         methodName: 'getBranchChanges'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to get branch changes: ${error.message}`)
     }
@@ -1726,11 +2161,15 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/merge`, {
+      const response = await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/merge`, {
         method: 'POST',
         body: JSON.stringify(requestBody),
         methodName: 'mergeBranch'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       // Handle merge conflicts specifically
       if (error.message.includes('conflicts') || error.message.includes('409')) {
@@ -1753,10 +2192,14 @@ export class CoreService extends BaseService {
     }
 
     try {
-      return await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/reset`, {
+      const response = await this._request(`/projects/${projectId}/branches/${encodeURIComponent(branchName)}/reset`, {
         method: 'POST',
         methodName: 'resetBranch'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to reset branch: ${error.message}`)
     }
@@ -1777,11 +2220,15 @@ export class CoreService extends BaseService {
     const { version, branch = 'main' } = publishData
 
     try {
-      return await this._request(`/projects/${projectId}/publish`, {
+      const response = await this._request(`/projects/${projectId}/publish`, {
         method: 'POST',
         body: JSON.stringify({ version, branch }),
         methodName: 'publishVersion'
       })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
     } catch (error) {
       throw new Error(`Failed to publish version: ${error.message}`)
     }
@@ -1930,6 +2377,164 @@ export class CoreService extends BaseService {
     return await this.deleteBranch(projectId, branchName)
   }
 
+  // ==================== ADMIN METHODS ====================
+
+  /**
+   * Get admin users list with comprehensive filtering and search capabilities
+   * Requires admin or super_admin global role
+   */
+  async getAdminUsers (params = {}) {
+    this._requireReady('getAdminUsers')
+
+    const {
+      emails,
+      ids,
+      query,
+      status,
+      page = 1,
+      limit = 50,
+      sort = { field: 'createdAt', order: 'desc' }
+    } = params
+
+    const queryParams = new URLSearchParams()
+
+    // Add query parameters
+    if (emails) {
+      queryParams.append('emails', emails)
+    }
+    if (ids) {
+      queryParams.append('ids', ids)
+    }
+    if (query) {
+      queryParams.append('query', query)
+    }
+    if (status) {
+      queryParams.append('status', status)
+    }
+    if (page) {
+      queryParams.append('page', page.toString())
+    }
+    if (limit) {
+      queryParams.append('limit', limit.toString())
+    }
+    if (sort && sort.field) {
+      queryParams.append('sort[field]', sort.field)
+      queryParams.append('sort[order]', sort.order || 'desc')
+    }
+
+    const queryString = queryParams.toString()
+    const url = `/users/admin/users${queryString ? `?${queryString}` : ''}`
+
+    try {
+      const response = await this._request(url, {
+        method: 'GET',
+        methodName: 'getAdminUsers'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to get admin users: ${error.message}`)
+    }
+  }
+
+  /**
+   * Assign projects to a specific user
+   * Requires admin or super_admin global role
+   */
+  async assignProjectsToUser (userId, options = {}) {
+    this._requireReady('assignProjectsToUser')
+
+    if (!userId) {
+      throw new Error('User ID is required')
+    }
+
+    const {
+      projectIds,
+      role = 'guest'
+    } = options
+
+    const requestBody = {
+      userId,
+      role
+    }
+
+    // Only include projectIds if provided (otherwise assigns all projects)
+    if (projectIds && Array.isArray(projectIds)) {
+      requestBody.projectIds = projectIds
+    }
+
+    try {
+      const response = await this._request('/assign-projects', {
+        method: 'POST',
+        body: JSON.stringify(requestBody),
+        methodName: 'assignProjectsToUser'
+      })
+      if (response.success) {
+        return response.data
+      }
+      throw new Error(response.message)
+    } catch (error) {
+      throw new Error(`Failed to assign projects to user: ${error.message}`)
+    }
+  }
+
+  /**
+   * Helper method for admin users search
+   */
+  async searchAdminUsers (searchQuery, options = {}) {
+    return await this.getAdminUsers({
+      query: searchQuery,
+      ...options
+    })
+  }
+
+  /**
+   * Helper method to get admin users by email list
+   */
+  async getAdminUsersByEmails (emails, options = {}) {
+    const emailList = Array.isArray(emails) ? emails.join(',') : emails
+    return await this.getAdminUsers({
+      emails: emailList,
+      ...options
+    })
+  }
+
+  /**
+   * Helper method to get admin users by ID list
+   */
+  async getAdminUsersByIds (ids, options = {}) {
+    const idList = Array.isArray(ids) ? ids.join(',') : ids
+    return await this.getAdminUsers({
+      ids: idList,
+      ...options
+    })
+  }
+
+  /**
+   * Helper method to assign specific projects to a user with a specific role
+   */
+  async assignSpecificProjectsToUser (userId, projectIds, role = 'guest') {
+    if (!Array.isArray(projectIds) || projectIds.length === 0) {
+      throw new Error('Project IDs must be a non-empty array')
+    }
+
+    return await this.assignProjectsToUser(userId, {
+      projectIds,
+      role
+    })
+  }
+
+  /**
+   * Helper method to assign all projects to a user with a specific role
+   */
+  async assignAllProjectsToUser (userId, role = 'guest') {
+    return await this.assignProjectsToUser(userId, {
+      role
+    })
+  }
+
   // Cleanup
   destroy () {
     if (this._tokenManager) {