@symbo.ls/sdk 3.1.1 → 3.2.3

package/README.md

@@ -12,8 +12,8 @@ import { SDK } from '@symbo.ls/sdk'
 
 const sdk = new SDK({
   useNewServices: true,  // Use new service implementations
-  baseUrl: 'https://api.symbols.app',
-  socketUrl: 'https://socket.symbols.app',
+  apiUrl: 'https://api.symbols.app',
+  socketUrl: 'https://api.symbols.app',
   timeout: 30000,
   retryAttempts: 3,
   debug: false
@@ -396,8 +396,8 @@ sdk.destroy()
 ```javascript
 const options = {
   useNewServices: true,
-  baseUrl: 'https://api.symbols.app',
-  socketUrl: 'https://socket.symbols.app',
+  apiUrl: 'https://api.symbols.app',
+  socketUrl: 'https://api.symbols.app',
   timeout: 30000,
   retryAttempts: 3,
   debug: false
@@ -418,7 +418,7 @@ const canEdit = sdk.hasPermission(projectId, 'edit')
 const hasCopilot = sdk.checkProjectFeature(projectTier, 'aiCopilot')
 
 // Check if user has global admin access
-const isAdmin = sdk.hasGlobalPermission('admin', 'manageUsers')
+const isAdmin = sdk.hasGlobalPermission('admin', 'governance')
 ```
 
 ## Permission Types
@@ -494,11 +494,11 @@ if (isProjectAdmin) {
 const canMerge = projectId => {
   const hasPermission = sdk.hasPermission(projectId, 'merge')
   const isProtectedBranch = sdk.getBranchProtection(projectId)
-  
+
   if (isProtectedBranch) {
     return hasPermission && sdk.hasPermission(projectId, 'manage')
   }
-  
+
   return hasPermission
 }
 ```
@@ -510,8 +510,8 @@ const canMerge = projectId => {
 const ROLE_PERMISSIONS = {
   guest: ['viewPublicProjects'],
   user: ['viewPublicProjects', 'createProject'],
-  admin: ['viewPublicProjects', 'createProject', 'manageUsers'],
-  superAdmin: ['viewPublicProjects', 'createProject', 'manageUsers', 'managePlatform']
+  admin: ['viewPublicProjects', 'createProject', 'governance'],
+  superAdmin: ['viewPublicProjects', 'createProject', 'governance', 'managePlatform']
 }
 ```
 
@@ -551,7 +551,7 @@ if (canInvite) {
   const tier = sdk.getProjectTier(projectId)
   const maxMembers = TIER_LIMITS[tier].teamMembers
   const currentSize = await sdk.getCurrentTeamSize()
-  
+
   if (currentSize < maxMembers) {
     await sdk.inviteTeamMember(email, 'editor')
   }
@@ -563,7 +563,7 @@ if (canInvite) {
 const handleAIFeature = async (projectId) => {
   const tier = await sdk.getProjectTier(projectId)
   const copilotAccess = sdk.checkProjectFeature(tier, 'aiCopilot')
-  
+
   if (copilotAccess) {
     const tokensLeft = await sdk.getAITokensRemaining(projectId)
     return {
@@ -572,7 +572,7 @@ const handleAIFeature = async (projectId) => {
       maxTokens: copilotAccess
     }
   }
-  
+
   return { hasAccess: false }
 }
 ```
@@ -582,7 +582,7 @@ const handleAIFeature = async (projectId) => {
 const protectBranch = async (projectId, branchName) => {
   const canManage = sdk.hasPermission(projectId, 'manage')
   if (!canManage) return false
-  
+
   return sdk.setBranchProtection(projectId, branchName, {
     requireReview: true,
     requiredApprovals: 2,
@@ -614,5 +614,166 @@ try {
 }
 ```
 
+## Token Management
+
+The SDK now includes automatic token management with persistence and refresh capabilities:
+
+### Features
+- **Automatic Token Refresh**: Tokens are refreshed automatically before expiration
+- **Persistent Storage**: Tokens persist across page refreshes using localStorage
+- **Secure Handling**: Automatic cleanup on logout and error handling
+- **Flexible Storage**: Supports localStorage, sessionStorage, or memory storage
+
+### Configuration
+```javascript
+import { getTokenManager } from '@symbols/sdk'
+
+// Configure token management (optional - handled automatically by CoreService)
+const tokenManager = getTokenManager({
+  storageType: 'localStorage', // 'localStorage' | 'sessionStorage' | 'memory'
+  refreshBuffer: 60 * 1000, // Refresh 1 minute before expiry
+  apiUrl: '/api',
+  onTokenRefresh: (tokens) => console.log('Token refreshed'),
+  onTokenExpired: () => console.log('Session expired'),
+  onTokenError: (error) => console.error('Token error:', error)
+})
+```
+
+### Usage with CoreService
+```javascript
+// Initialize SDK - token management is automatic
+const symbols = new Symbols({
+  appKey: 'your-app-key',
+  authToken: 'your-initial-token' // Optional
+})
+
+// Login - tokens are automatically managed
+const loginResult = await symbols.login('user@example.com', 'password')
+
+// All subsequent API calls automatically use fresh tokens
+const projects = await symbols.getProjects()
+const projectData = await symbols.getProjectData('projectId123')
+
+// Logout - tokens are automatically cleared
+await symbols.logout()
+```
+
+## New Core Service Methods
+
+### Project Data Management (Symstory Replacement)
+```javascript
+// Apply changes to project
+await symbols.applyProjectChanges('projectId', [
+  ['update', ['components', 'Button'], { color: 'blue' }],
+  ['delete', ['pages', 'oldPage']]
+], { message: 'Update button color', type: 'patch' })
+
+// Get current project data
+const projectData = await symbols.getProjectData('projectId', {
+  branch: 'main',
+  includeHistory: true
+})
+
+// Restore to previous version
+await symbols.restoreProjectVersion('projectId', '1.2.0', {
+  message: 'Rollback to stable version'
+})
+
+// Helper methods for single operations
+await symbols.updateProjectItem('projectId', ['components', 'Button'], { color: 'red' })
+await symbols.deleteProjectItem('projectId', ['pages', 'unused'])
+await symbols.setProjectValue('projectId', ['settings', 'theme'], 'dark')
+```
+
+### Pull Request Management
+```javascript
+// Create pull request
+const pr = await symbols.createPullRequest('projectId', {
+  source: 'feature/new-ui',
+  target: 'main',
+  title: 'Add new UI components',
+  description: 'Modern UI overhaul'
+})
+
+// List pull requests
+const { pullRequests, pagination } = await symbols.listPullRequests('projectId', {
+  status: 'open',
+  page: 1,
+  limit: 10
+})
+
+// Review pull request
+await symbols.approvePullRequest('projectId', 'pr_123', 'Great work!')
+
+// Request changes
+await symbols.requestPullRequestChanges('projectId', 'pr_123', [
+  {
+    file: 'src/Button.js',
+    line: 25,
+    comment: 'Add error handling',
+    type: 'issue'
+  }
+])
+
+// Merge pull request
+await symbols.mergePullRequest('projectId', 'pr_123')
+
+// Get diff
+const diff = await symbols.getPullRequestDiff('projectId', 'pr_123')
+```
+
+### Branch Management
+```javascript
+// List branches
+const branches = await symbols.listBranches('projectId')
+
+// Create branch
+await symbols.createFeatureBranch('projectId', 'user authentication')
+// Creates: 'feature/user-authentication'
+
+// Check branch status
+const status = await symbols.getBranchStatus('projectId', 'feature/new-ui')
+
+// Preview merge
+const preview = await symbols.previewMerge('projectId', 'feature/new-ui', 'main')
+if (preview.data.conflicts.length === 0) {
+  // Commit merge if no conflicts
+  await symbols.commitMerge('projectId', 'feature/new-ui', {
+    message: 'Add new UI features',
+    type: 'minor'
+  })
+}
+
+// Delete branch safely
+await symbols.deleteBranchSafely('projectId', 'feature/old-feature')
+
+// Publish version
+await symbols.publishVersion('projectId', {
+  version: '1.2.0',
+  branch: 'main'
+})
+```
+
+## Error Handling
+
+The SDK provides comprehensive error handling for all scenarios:
+
+```javascript
+try {
+  await symbols.mergePullRequest('projectId', 'pr_123')
+} catch (error) {
+  if (error.message.includes('conflicts')) {
+    // Handle merge conflicts
+    console.log('Manual conflict resolution required')
+  } else if (error.message.includes('403')) {
+    // Handle permission errors
+    console.log('Insufficient permissions')
+  } else {
+    // Handle other errors
+    console.error('Operation failed:', error.message)
+  }
+}
+```
+
 
 

package/dist/cjs/config/environment.js

@@ -17,9 +17,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var environment_exports = {};
 __export(environment_exports, {
-  default: () => environment_default
+  default: () => environment_default,
+  getConfig: () => getConfig
 });
 module.exports = __toCommonJS(environment_exports);
+var import_utils = require("@domql/utils");
 const CONFIG = {
   // Common defaults for all environments
   common: {
@@ -33,17 +35,14 @@ const CONFIG = {
   },
   // Environment-specific configurations
   local: {
-    baseUrl: "http://localhost:3000",
-    // For symstory api
+    // local
     socketUrl: "http://localhost:8080",
     // For socket api
-    routerUrl: "http://localhost:3090",
-    // For router api
-    apiUrl: "http://localhost:13335",
+    apiUrl: "http://localhost:8080",
     // For server api
     basedEnv: "development",
     // For based api
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     // For based api
     basedOrg: "symbols",
     // For based api
@@ -56,41 +55,45 @@ const CONFIG = {
     }
   },
   development: {
-    baseUrl: "https://story.symbo.ls",
-    socketUrl: "https://socket.symbols.app",
-    routerUrl: "https://router.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "development",
-    basedProject: "platform-v2",
+    socketUrl: "https://dev.api.symbols.app",
+    apiUrl: "https://dev.api.symbols.app",
+    githubClientId: "Ov23liHxyWFBxS8f1gnF"
+  },
+  testing: {
+    socketUrl: "https://test.api.symbols.app",
+    apiUrl: "https://test.api.symbols.app",
+    basedEnv: "testing",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
+  upcoming: {
+    socketUrl: "https://upcoming.api.symbols.app",
+    apiUrl: "https://upcoming.api.symbols.app",
+    githubClientId: "Ov23liWF7NvdZ056RV5J"
+  },
   staging: {
-    baseUrl: "https://staging.story.symbo.ls",
-    socketUrl: "https://staging.socket.symbols.app",
-    routerUrl: "https://staging.router.symbols.app",
+    socketUrl: "https://staging.api.symbols.app",
     apiUrl: "https://staging.api.symbols.app",
     basedEnv: "staging",
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23ligwZDQVD0VfuWNa"
   },
   production: {
-    baseUrl: "https://story.symbo.ls",
-    socketUrl: "https://socket.symbols.app",
-    routerUrl: "https://router.symbols.app",
+    socketUrl: "https://api.symbols.app",
     apiUrl: "https://api.symbols.app",
     basedEnv: "production",
-    basedProject: "platform-v2",
+    basedProject: "platform-v2-sm",
     basedOrg: "symbols",
     githubClientId: "Ov23liFAlOEIXtX3dBtR"
   }
 };
 const getEnvironment = () => {
-  const env = process.env.SYMBOLS_APP_ENV || "" || "development";
+  // @preserve-env
+  const env = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
   if (!CONFIG[env]) {
-    console.warn(`Unknown environment "${env}", falling back to development`);
-    return "development";
+    throw new Error(`Unknown environment "${env}"`);
   }
   return env;
 };
@@ -100,25 +103,21 @@ const getConfig = () => {
     const envConfig = { ...CONFIG.common, ...CONFIG[env] };
     const finalConfig = {
       ...envConfig,
-      baseUrl: process.env.SYMBOLS_APP_BASE_URL || envConfig.baseUrl,
       socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
-      routerUrl: process.env.SYMBOLS_APP_ROUTER_URL || envConfig.routerUrl,
       apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
       basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
       basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
       basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
       githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
-      isDevelopment: env === "development" || env === "local",
+      isDevelopment: (0, import_utils.isDevelopment)(env),
+      isTesting: env === "testing",
       isStaging: env === "staging",
       isProduction: env === "production"
+      // Store all environment variables for potential future use
     };
     const requiredFields = [
-      "baseUrl",
       "socketUrl",
       "apiUrl",
-      "basedEnv",
-      "basedProject",
-      "basedOrg",
       "githubClientId",
       "googleClientId"
     ];
@@ -131,9 +130,7 @@ const getConfig = () => {
     if (finalConfig.isDevelopment) {
       console.log(
         "environment in SDK:",
-        env,
-        "",
-        process.env.SYMBOLS_APP_ENV
+        env || process.env.NODE_ENV || process.env.NODE_ENV
       );
       console.log(finalConfig);
     }
@@ -141,14 +138,7 @@ const getConfig = () => {
   } catch (error) {
     console.error("Failed to load environment configuration:", error);
     return {
-      baseUrl: "https://story.symbo.ls",
-      socketUrl: "https://socket.symbols.app",
-      routerUrl: "https://router.symbols.app",
-      apiUrl: "https://api.symbols.app",
-      basedEnv: "development",
-      basedProject: "platform-v2",
-      basedOrg: "symbols",
-      githubClientId: "Ov23liHxyWFBxS8f1gnF"
+      ...CONFIG.development
     };
   }
 };

package/dist/cjs/index.js

@@ -28,14 +28,17 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   SDK: () => SDK,
+  createAuthService: () => import_services3.createAuthService,
+  createCollabService: () => import_services3.createCollabService,
+  createCoreService: () => import_services3.createCoreService,
   default: () => index_default,
   environment: () => import_environment2.default
 });
 module.exports = __toCommonJS(index_exports);
 var import_services = require("./services/index.js");
 var import_services2 = require("./utils/services.js");
-var import_SymstoryService = require("./services/SymstoryService.js");
 var import_environment = __toESM(require("./config/environment.js"), 1);
+var import_services3 = require("./services/index.js");
 var import_environment2 = __toESM(require("./config/environment.js"), 1);
 class SDK {
   constructor(options = {}) {
@@ -44,19 +47,13 @@ class SDK {
     this._options = this._validateOptions(options);
     this._createServiceProxies();
   }
+  // Initialize SDK with context
   async initialize(context = {}) {
     this._context = {
       ...this._context,
       ...context
     };
     await Promise.all([
-      this._initService(
-        "based",
-        (0, import_services.createBasedService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
       this._initService(
         "auth",
         (0, import_services.createAuthService)({
@@ -65,22 +62,15 @@ class SDK {
         })
       ),
       this._initService(
-        "socket",
-        (0, import_services.createSocketService)({
+        "core",
+        (0, import_services.createCoreService)({
           context: this._context,
           options: this._options
         })
       ),
       this._initService(
-        "symstory",
-        (0, import_services.createSymstoryService)({
-          context: this._context,
-          options: this._options
-        })
-      ),
-      this._initService(
-        "ai",
-        (0, import_services.createAIService)({
+        "collab",
+        (0, import_services.createCollabService)({
           context: this._context,
           options: this._options
         })
@@ -104,7 +94,7 @@ class SDK {
     const defaults = {
       useNewServices: true,
       // Use new service implementations by default
-      baseUrl: import_environment.default.baseUrl,
+      apiUrl: import_environment.default.apiUrl,
       socketUrl: import_environment.default.socketUrl,
       timeout: 3e4,
       retryAttempts: 3,
@@ -127,14 +117,12 @@ class SDK {
     };
     for (const service of this._services.values()) {
       service.updateContext(this._context);
-      if (service instanceof import_SymstoryService.SymstoryService) {
-        service.init();
-      }
     }
   }
   // Check if SDK is ready
   isReady() {
-    return Array.from(this._services.values()).every(
+    const sdkServices = Array.from(this._services.values());
+    return sdkServices.length > 0 && sdkServices.every(
       (service) => service.isReady()
     );
   }
@@ -165,5 +153,24 @@ class SDK {
       }
     }
   }
+  /**
+   * Destroys all services and cleans up resources
+   * @returns {Promise<boolean>} Returns true when cleanup is complete
+   */
+  async destroy() {
+    try {
+      const destroyPromises = Array.from(this._services.entries()).filter(([, service]) => typeof service.destroy === "function").map(async ([name, service]) => {
+        await service.destroy();
+        console.log(`Service ${name} destroyed successfully`);
+      });
+      await Promise.all(destroyPromises);
+      this._services.clear();
+      this._context = {};
+      return true;
+    } catch (error) {
+      console.error("Error during SDK destruction:", error);
+      throw error;
+    }
+  }
 }
 var index_default = SDK;

package/dist/cjs/services/AIService.js

@@ -27,7 +27,7 @@ class AIService extends import_BaseService.BaseService {
     this._client = null;
     this._initialized = false;
     this._defaultConfig = {
-      baseUrl: "https://api.openai.com/v1/engines/text-curie/completions",
+      apiUrl: "https://api.openai.com/v1/engines/text-curie/completions",
       temperature: 0,
       maxTokens: 2e3,
       headers: {
@@ -71,7 +71,7 @@ class AIService extends import_BaseService.BaseService {
     };
   }
   validateConfig(config = {}) {
-    const requiredFields = ["baseUrl", "temperature", "maxTokens"];
+    const requiredFields = ["apiUrl", "temperature", "maxTokens"];
     const missingFields = requiredFields.filter((field) => !config[field]);
     if (missingFields.length > 0) {
       throw new Error(
@@ -99,7 +99,7 @@ class AIService extends import_BaseService.BaseService {
           ...opts
         })
       };
-      const response = await this._request(config.baseUrl, options);
+      const response = await this._request(config.apiUrl, options);
       return response;
     } catch (error) {
       throw new Error(`AI prompt failed: ${error.message}`);

package/dist/cjs/services/AuthService.js

@@ -109,15 +109,53 @@ class AuthService extends import_BaseService.BaseService {
   async googleAuth(idToken) {
     try {
       const based = this._getBasedService("googleAuth");
-      return await based.call("users:google-auth", { idToken });
+      const response = await based.call("users:google-auth", { idToken });
+      if (this._initialized) {
+        this.updateContext({ authToken: response.token });
+      }
+      based.setAuthState({
+        token: response.token,
+        userId: response.userId,
+        persistent: true
+      });
+      return response;
     } catch (error) {
       throw new Error(`Google auth failed: ${error.message}`);
     }
   }
+  async googleAuthCallback(code, redirectUri) {
+    try {
+      const based = this._getBasedService("googleAuthCallback");
+      const response = await based.call("users:google-auth-callback", {
+        code,
+        redirectUri
+      });
+      if (this._initialized) {
+        this.updateContext({ authToken: response.token });
+      }
+      based.setAuthState({
+        token: response.token,
+        userId: response.userId,
+        persistent: true
+      });
+      return response;
+    } catch (error) {
+      throw new Error(`Google auth callback failed: ${error.message}`);
+    }
+  }
   async githubAuth(code) {
     try {
       const based = this._getBasedService("githubAuth");
-      return await based.call("users:github-auth", { code });
+      const response = await based.call("users:github-auth", { code });
+      if (this._initialized) {
+        this.updateContext({ authToken: response.token });
+      }
+      based.setAuthState({
+        token: response.token,
+        userId: response.userId,
+        persistent: true
+      });
+      return response;
     } catch (error) {
       throw new Error(`GitHub auth failed: ${error.message}`);
     }
@@ -126,7 +164,7 @@ class AuthService extends import_BaseService.BaseService {
     this._requireReady("logout");
     try {
       const based = this._getBasedService("logout");
-      await based.call("logout");
+      await based.call("users:logout");
       this.updateContext({ authToken: null });
     } catch (error) {
       throw new Error(`Logout failed: ${error.message}`);
@@ -308,6 +346,7 @@ class AuthService extends import_BaseService.BaseService {
     }, 0);
   }
   async getProjectMembers(projectId) {
+    var _a;
     this._requireReady("getProjectMembers");
     if (!projectId) {
       throw new Error("Project ID is required");
@@ -316,6 +355,8 @@ class AuthService extends import_BaseService.BaseService {
       const based = this._getBasedService("getProjectMembers");
       return await based.call("projects:get-members", { projectId });
     } catch (error) {
+      if ((_a = error.message) == null ? void 0 : _a.includes("Authentication failed. Please try again"))
+        window.location.reload();
       throw new Error(`Failed to get project members: ${error.message}`);
     }
   }