@symbo.ls/sdk 3.1.2 → 3.2.3

package/dist/cjs/services/CoreService.js

@@ -38,18 +38,18 @@ class CoreService extends import_BaseService.BaseService {
     super(config);
     this._client = null;
     this._initialized = false;
-    this._baseUrl = null;
+    this._apiUrl = null;
     this._tokenManager = null;
   }
   init({ context }) {
     try {
       const { appKey, authToken } = context || this._context;
-      this._baseUrl = import_environment.default.apiUrl || import_environment.default.baseUrl;
-      if (!this._baseUrl) {
+      this._apiUrl = import_environment.default.apiUrl;
+      if (!this._apiUrl) {
         throw new Error("Core service base URL not configured");
       }
       this._tokenManager = (0, import_TokenManager.getTokenManager)({
-        apiUrl: this._baseUrl,
+        apiUrl: this._apiUrl,
         onTokenRefresh: (tokens) => {
           this.updateContext({ authToken: tokens.accessToken });
         },
@@ -60,12 +60,12 @@ class CoreService extends import_BaseService.BaseService {
           console.error("Token management error:", error);
         }
       });
-      if (authToken) {
+      if (authToken && !this._tokenManager.hasTokens()) {
         this._tokenManager.setTokens({ access_token: authToken });
       }
       this._info = {
         config: {
-          baseUrl: this._baseUrl,
+          apiUrl: this._apiUrl,
           appKey: appKey ? `${appKey.substr(0, 4)}...${appKey.substr(-4)}` : null,
           hasToken: Boolean(authToken)
         }
@@ -83,11 +83,15 @@ class CoreService extends import_BaseService.BaseService {
       "register",
       "login",
       "googleAuth",
+      "googleAuthCallback",
       "githubAuth",
       "requestPasswordReset",
       "confirmPasswordReset",
       "confirmRegistration",
-      "verifyEmail"
+      "verifyEmail",
+      "listPublicProjects",
+      "getPublicProject",
+      "getHealthStatus"
     ]);
     return !noInitMethods.has(methodName);
   }
@@ -118,24 +122,34 @@ class CoreService extends import_BaseService.BaseService {
       authHeader: this._tokenManager.getAuthHeader()
     };
   }
+  // 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 defaultHeaders = {
-      "Content-Type": "application/json"
-    };
+    const url = `${this._apiUrl}/core${endpoint}`;
+    const defaultHeaders = {};
+    if (!(options.body instanceof FormData)) {
+      defaultHeaders["Content-Type"] = "application/json";
+    }
     if (this._requiresInit(options.methodName) && this._tokenManager) {
       try {
         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) {
@@ -145,7 +159,6 @@ class CoreService extends import_BaseService.BaseService {
       const { authToken } = this._context;
       if (authToken) {
         defaultHeaders.Authorization = `Bearer ${authToken}`;
-        console.log(`[CoreService] Using context token for ${options.methodName}`);
       }
     }
     try {
@@ -172,11 +185,15 @@ class CoreService extends import_BaseService.BaseService {
   // ==================== AUTH METHODS ====================
   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}`);
     }
@@ -202,7 +219,10 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -228,11 +248,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -258,7 +282,10 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -284,40 +311,84 @@ class CoreService extends import_BaseService.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) {
+    var _a;
+    try {
+      const response = await this._request("/auth/google/callback", {
+        method: "POST",
+        body: JSON.stringify({ code, redirectUri }),
+        methodName: "googleAuthCallback"
+      });
+      if (response.success && response.data && response.data.tokens) {
+        const { tokens } = response.data;
+        const tokenData = {
+          access_token: tokens.accessToken,
+          refresh_token: tokens.refreshToken,
+          expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
+          token_type: "Bearer"
+        };
+        if (this._tokenManager) {
+          this._tokenManager.setTokens(tokenData);
+        }
+        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}`);
     }
   }
   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}`);
     }
   }
   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}`);
     }
@@ -325,10 +396,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -336,11 +411,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -348,10 +427,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -379,35 +462,57 @@ class CoreService extends import_BaseService.BaseService {
         try {
           await this._tokenManager.ensureValidToken();
         } catch (error) {
-          this._tokenManager.clearTokens();
+          console.warn("[CoreService] Token refresh failed:", error.message);
+          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}`
+            };
+          }
           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
           };
         }
       }
+      const currentAccessToken = this._tokenManager.getAccessToken();
+      if (!currentAccessToken) {
+        return {
+          userId: false,
+          authToken: false
+        };
+      }
       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 == null ? void 0 : userProjects.data) || []
-          },
+          userId: currentUser.user.id,
+          authToken: currentAccessToken,
+          ...currentUser,
           error: null
         };
       } catch (error) {
-        this._tokenManager.clearTokens();
+        console.warn("[CoreService] Failed to get user data:", error.message);
+        if (error.message.includes("401") || error.message.includes("403")) {
+          this._tokenManager.clearTokens();
+          return {
+            userId: false,
+            authToken: false,
+            error: `Authentication failed: ${error.message}`
+          };
+        }
         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,
@@ -419,10 +524,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -430,11 +539,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -442,10 +555,17 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -456,10 +576,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -470,13 +594,17 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -485,50 +613,134 @@ class CoreService extends import_BaseService.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();
+      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();
+      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}`);
     }
@@ -539,11 +751,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -554,11 +770,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -569,11 +789,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -584,11 +808,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -599,26 +827,34 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -629,10 +865,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -643,10 +883,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -658,40 +902,62 @@ class CoreService extends import_BaseService.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;
+    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
+      };
+      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}`);
     }
@@ -702,11 +968,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -717,10 +987,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -730,10 +1004,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -744,10 +1022,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -758,11 +1040,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -773,11 +1059,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -797,19 +1087,28 @@ class CoreService extends import_BaseService.BaseService {
       formData.append("tags", JSON.stringify(options.tags));
     }
     if (options.visibility) {
-      formData.append("visibility", 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}`);
     }
@@ -823,13 +1122,17 @@ class CoreService extends import_BaseService.BaseService {
     formData.append("icon", iconFile);
     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}`);
     }
@@ -848,7 +1151,7 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Project ID is required for checkout");
     }
     try {
-      return await this._request("/payments/checkout", {
+      const response = await this._request("/payments/checkout", {
         method: "POST",
         body: JSON.stringify({
           projectId,
@@ -859,6 +1162,10 @@ class CoreService extends import_BaseService.BaseService {
         }),
         methodName: "checkout"
       });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
     } catch (error) {
       throw new Error(`Failed to checkout: ${error.message}`);
     }
@@ -869,10 +1176,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -884,11 +1195,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -899,10 +1214,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -913,10 +1232,14 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -927,7 +1250,7 @@ class CoreService extends import_BaseService.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,
@@ -936,6 +1259,10 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -943,10 +1270,14 @@ class CoreService extends import_BaseService.BaseService {
   // ==================== UTILITY METHODS ====================
   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}`);
     }
@@ -980,7 +1311,10 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -996,17 +1330,23 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -1030,10 +1370,14 @@ class CoreService extends import_BaseService.BaseService {
       limit: limit.toString()
     }).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}`);
     }
@@ -1056,7 +1400,7 @@ class CoreService extends import_BaseService.BaseService {
       type = "patch"
     } = options;
     try {
-      return await this._request(`/projects/${projectId}/restore`, {
+      const response = await this._request(`/projects/${projectId}/restore`, {
         method: "POST",
         body: JSON.stringify({
           version,
@@ -1066,6 +1410,10 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -1158,11 +1506,15 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Source branch, target branch, and title are required");
     }
     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}`);
     }
@@ -1194,10 +1546,14 @@ class CoreService extends import_BaseService.BaseService {
       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}`);
     }
@@ -1214,10 +1570,14 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Pull request ID is required");
     }
     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}`);
     }
@@ -1238,11 +1598,15 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error(`Invalid review status. Must be one of: ${validStatuses.join(", ")}`);
     }
     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}`);
     }
@@ -1262,11 +1626,15 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Comment value is required");
     }
     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}`);
     }
@@ -1287,7 +1655,10 @@ class CoreService extends import_BaseService.BaseService {
         method: "POST",
         methodName: "mergePullRequest"
       });
-      return response;
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
     } catch (error) {
       if (error.message.includes("conflicts") || error.message.includes("409")) {
         throw new Error(`Pull request has merge conflicts: ${error.message}`);
@@ -1307,10 +1678,14 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Pull request ID is required");
     }
     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}`);
     }
@@ -1424,10 +1799,14 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Project ID is required");
     }
     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}`);
     }
@@ -1445,11 +1824,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -1469,10 +1852,14 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Cannot delete main branch");
     }
     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}`);
     }
@@ -1495,11 +1882,15 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Cannot rename main branch");
     }
     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}`);
     }
@@ -1507,7 +1898,7 @@ class CoreService extends import_BaseService.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");
@@ -1529,10 +1920,14 @@ class CoreService extends import_BaseService.BaseService {
     const queryString = queryParams.toString();
     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}`);
     }
@@ -1563,11 +1958,15 @@ class CoreService extends import_BaseService.BaseService {
       ...changes && { changes }
     };
     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) {
       if (error.message.includes("conflicts") || error.message.includes("409")) {
         throw new Error(`Merge conflicts detected: ${error.message}`);
@@ -1587,10 +1986,14 @@ class CoreService extends import_BaseService.BaseService {
       throw new Error("Branch name is required");
     }
     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}`);
     }
@@ -1608,11 +2011,15 @@ class CoreService extends import_BaseService.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}`);
     }
@@ -1738,6 +2145,143 @@ class CoreService extends import_BaseService.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();
+    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
+    };
+    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) {