@symbo.ls/sdk 2.34.35 → 3.1.1

package/README.md

@@ -12,8 +12,8 @@ import { SDK } from '@symbo.ls/sdk'
 
 const sdk = new SDK({
   useNewServices: true,  // Use new service implementations
-  apiUrl: 'https://api.symbols.app',
-  socketUrl: 'https://api.symbols.app',
+  baseUrl: 'https://api.symbols.app',
+  socketUrl: 'https://socket.symbols.app',
   timeout: 30000,
   retryAttempts: 3,
   debug: false
@@ -377,147 +377,6 @@ const ai = sdk.getService('ai')
 const response = await ai.prompt(query, options)
 ```
 
-### Tracking Service (Grafana Faro)
-```javascript
-// 1) Initialize SDK with tracking config (early in app startup)
-const sdk = new SDK({
-  useNewServices: true,
-  apiUrl: 'https://api.symbols.app',
-  // Tracking configuration mirrors TrackingService options
-  tracking: {
-    url: 'https://<your-faro-receiver-url>', // FO ingest/collector URL
-    appName: 'Symbols Platform',
-    environment: 'development',              // 'production' | 'staging' | 'testing' | 'development'
-    appVersion: '1.0.0',
-    sessionTracking: true,
-    enableTracing: true,                     // adds browser tracing when available
-    globalAttributes: { region: 'us-east-1' }
-  }
-})
-await sdk.initialize()
-
-// 2) Get the tracking service
-const tracking = sdk.getService('tracking')
-
-// 3) Send signals
-tracking.trackEvent('purchase', { amount: 42, currency: 'USD' })
-tracking.trackMeasurement('cart_value', { value: 42 })
-tracking.logError('checkout failed', { step: 'payment' })
-tracking.trackView('Checkout', { stage: 'payment' })
-tracking.setUser({ id: 'u_123', email: 'user@example.com' })
-```
-
-#### Configuration
-Provide these under `tracking` when creating the `SDK` (or later via `tracking.configureTracking()`):
-
-- `url` string: Frontend Observability/Faro ingestion URL. If omitted and no custom transports are provided, tracking is disabled.
-- `appName` string: Logical application name used in Grafana dashboards.
-- `appVersion` string: App version shown in Grafana.
-- `environment` string: One of your environments; default resolves from runtime (`production`, `staging`, `testing`, `development`).
-- `sessionTracking` boolean: Enable Faro session tracking. Default: `true`.
-- `enableTracing` boolean: Enable web tracing and send to Tempo (if collector configured). Default: `true`.
-- `globalAttributes` object: Key/values merged into every signal.
-- `user` object: Initial user attributes.
-- `maxQueueSize` number: Max queued calls before client setup. Default: `100`.
-- `isolate` boolean: Create an isolated Faro instance.
-- `transports` array | `transport` any: Custom transports (advanced).
-- `instrumentations` array | `instrumentationsFactory(runtime) => Promise<array>` | `webInstrumentationOptions` object: Control Faro web instrumentations.
-
-Note:
-- Tracking is automatically disabled in non‑browser environments.
-- Calls are queued until the Faro client is ready. For specific calls, pass `{ queue: false }` to skip queuing.
-
-#### Method reference
-The following methods are available via `sdk.getService('tracking')` and map to `utils/services.js`:
-
-- `configureTracking(trackingOptions)` / `configure(trackingOptions)`: Merge/override runtime tracking options (supports all config keys above).
-- `trackEvent(name, attributes?, options?)`
-  - `name` string (required)
-  - `attributes` object merged with global attributes
-  - `options` object:
-    - `domain` string | null
-    - `queue` boolean (whether to queue if client not ready)
-    - Additional transport options are forwarded to Faro
-  - Example:
-  ```javascript
-  tracking.trackEvent('signup_attempt', { method: 'email' }, { domain: 'auth' })
-  ```
-- `trackError(error, options?)` / `captureException(error, options?)`
-  - `error` Error | string
-  - `options` can be:
-    - object with Faro error options (`context`, `type`, `stackFrames`, `skipDedupe`, `timestampOverwriteMs`, etc.)
-    - or a plain context object (shorthand)
-    - `queue` boolean supported
-  - Example:
-  ```javascript
-  tracking.trackError(new Error('Login failed'), { context: { screen: 'Login' } })
-  ```
-- `logMessage(message, level='info', context?)`
-  - Convenience wrappers: `logDebug`, `logInfo`, `logWarning`/`logWarn`, `logErrorMessage`/`logError`
-  - `message` string | string[]
-  - `context` object merged with global attributes
-  - Example:
-  ```javascript
-  tracking.logWarning('Slow response', { route: '/checkout', ttfbMs: 900 })
-  ```
-- `addBreadcrumb(message, attributes?)`
-  - Adds a low‑cost breadcrumb via `trackEvent('breadcrumb', ...)`
-  - Example:
-  ```javascript
-  tracking.addBreadcrumb('Open modal', { id: 'planLimits' })
-  ```
-- `trackMeasurement(type, values, options?)`
-  - `type` string (required)
-  - `values` object | number. If number, it becomes `{ value: <number> }`.
-  - `options`:
-    - `attributes` object (merged into payload.attributes)
-    - `context` object (transport context)
-    - `queue` boolean
-    - Any additional transport options
-  - Example:
-  ```javascript
-  tracking.trackMeasurement('cart_value', 42, { context: { currency: 'USD' } })
-  ```
-- `trackView(name, attributes?)`
-  - Sets the current view/page in Faro
-  - Example:
-  ```javascript
-  tracking.trackView('Dashboard', { section: 'Analytics' })
-  ```
-- `setUser(user, options?)` / `clearUser()`
-  - `user` object with arbitrary attributes; supports `{ queue: boolean }`
-  - Example:
-  ```javascript
-  tracking.setUser({ id: 'u_123', role: 'admin' })
-  ```
-- `setSession(session, options?)` / `clearSession()`
-  - Attach custom session data; supports `{ queue: boolean, ...sessionOptions }`
-- `setGlobalAttributes(attributes)` / `setGlobalAttribute(key, value)` / `removeGlobalAttribute(key)`
-  - Manage the global attributes merged into every signal
-- `flushQueue()`
-  - Immediately runs all queued calls (no‑op if client not ready)
-- `getClient()`
-  - Returns the underlying Faro client (or `null` if not ready)
-- `isEnabled()` / `isInitialized()`
-  - Status helpers
-
-#### Example: auth error tracking from services
-The SDK’s services automatically send errors to tracking:
-```javascript
-try {
-  await auth.login(email, password)
-} catch (error) {
-  // BaseService forwards details to tracking.trackError(...)
-}
-```
-
-#### Visualizing in Grafana
-- Use the Frontend Observability (Faro) data source and pick:
-  - Service = your `appName`
-  - Environment = your `environment`
-- Panels for page loads and Web Vitals require web instrumentations and real page traffic.
-- If self‑hosting with a Faro collector → Loki/Tempo, ensure the FO app is installed and the dashboard uses the FO data source; otherwise create custom panels with LogQL over Loki.
-
 ## Error Handling
 ```javascript
 try {
@@ -537,8 +396,8 @@ sdk.destroy()
 ```javascript
 const options = {
   useNewServices: true,
-  apiUrl: 'https://api.symbols.app',
-  socketUrl: 'https://api.symbols.app',
+  baseUrl: 'https://api.symbols.app',
+  socketUrl: 'https://socket.symbols.app',
   timeout: 30000,
   retryAttempts: 3,
   debug: false
@@ -559,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', 'governance')
+const isAdmin = sdk.hasGlobalPermission('admin', 'manageUsers')
 ```
 
 ## Permission Types
@@ -635,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
 }
 ```
@@ -651,8 +510,8 @@ const canMerge = projectId => {
 const ROLE_PERMISSIONS = {
   guest: ['viewPublicProjects'],
   user: ['viewPublicProjects', 'createProject'],
-  admin: ['viewPublicProjects', 'createProject', 'governance'],
-  superAdmin: ['viewPublicProjects', 'createProject', 'governance', 'managePlatform']
+  admin: ['viewPublicProjects', 'createProject', 'manageUsers'],
+  superAdmin: ['viewPublicProjects', 'createProject', 'manageUsers', 'managePlatform']
 }
 ```
 
@@ -692,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')
   }
@@ -704,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 {
@@ -713,7 +572,7 @@ const handleAIFeature = async (projectId) => {
       maxTokens: copilotAccess
     }
   }
-
+  
   return { hasAccess: false }
 }
 ```
@@ -723,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,
@@ -755,166 +614,5 @@ 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,11 +17,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var environment_exports = {};
 __export(environment_exports, {
-  default: () => environment_default,
-  getConfig: () => getConfig
+  default: () => environment_default
 });
 module.exports = __toCommonJS(environment_exports);
-var import_utils = require("@domql/utils");
 const CONFIG = {
   // Common defaults for all environments
   common: {
@@ -30,140 +28,69 @@ const CONFIG = {
     // Feature toggles that apply across all environments by default
     features: {
       newUserOnboarding: true,
-      betaFeatures: false,
-      // Tracking is enabled by default unless overridden per environment
-      trackingEnabled: true
+      betaFeatures: false
     }
   },
   // Environment-specific configurations
   local: {
-    // local
+    baseUrl: "http://localhost:3000",
+    // For symstory api
     socketUrl: "http://localhost:8080",
     // For socket api
-    apiUrl: "http://localhost:8080",
+    routerUrl: "http://localhost:3090",
+    // For router api
+    apiUrl: "http://localhost:13335",
     // For server api
     basedEnv: "development",
     // For based api
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     // For based api
     basedOrg: "symbols",
     // For based api
-    githubClientId: "Ov23liAFrsR0StbAO6PO",
+    githubClientId: "Ov23liHxyWFBxS8f1gnF",
     // For github api
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Localhost",
     // Environment-specific feature toggles (override common)
     features: {
-      // Disable tracking by default on localhost/dev machines
-      trackingEnabled: false,
+      betaFeatures: true
       // Enable beta features in local dev
-      betaFeatures: true,
-      // Preserve common defaults explicitly for local
-      newUserOnboarding: true
-    },
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "vZya3L2zpq8L6iI5WWMUZJZABvT63VDb",
-    typesenseHost: "localhost",
-    typesensePort: "8108",
-    typesenseProtocol: "http"
+    }
   },
   development: {
-    socketUrl: "https://dev.api.symbols.app",
-    apiUrl: "https://dev.api.symbols.app",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Dev",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  testing: {
-    socketUrl: "https://test.api.symbols.app",
-    apiUrl: "https://test.api.symbols.app",
-    basedEnv: "testing",
-    basedProject: "platform-v2-sm",
+    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",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Test",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  upcoming: {
-    socketUrl: "https://upcoming.api.symbols.app",
-    apiUrl: "https://upcoming.api.symbols.app",
-    githubClientId: "Ov23liWF7NvdZ056RV5J",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Upcoming",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23liHxyWFBxS8f1gnF"
   },
   staging: {
-    socketUrl: "https://staging.api.symbols.app",
+    baseUrl: "https://staging.story.symbo.ls",
+    socketUrl: "https://staging.socket.symbols.app",
+    routerUrl: "https://staging.router.symbols.app",
     apiUrl: "https://staging.api.symbols.app",
     basedEnv: "staging",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23ligwZDQVD0VfuWNa",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Staging",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  preview: {
-    socketUrl: "https://api.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "production",
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols Preview",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23ligwZDQVD0VfuWNa"
   },
   production: {
-    socketUrl: "https://api.symbols.app",
+    baseUrl: "https://story.symbo.ls",
+    socketUrl: "https://socket.symbols.app",
+    routerUrl: "https://router.symbols.app",
     apiUrl: "https://api.symbols.app",
     basedEnv: "production",
-    basedProject: "platform-v2-sm",
+    basedProject: "platform-v2",
     basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
+    githubClientId: "Ov23liFAlOEIXtX3dBtR"
   }
 };
 const getEnvironment = () => {
-  // @preserve-env
-  const env = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
+  const env = process.env.SYMBOLS_APP_ENV || "" || "development";
   if (!CONFIG[env]) {
-    throw new Error(`Unknown environment "${env}"`);
+    console.warn(`Unknown environment "${env}", falling back to development`);
+    return "development";
   }
   return env;
 };
@@ -173,33 +100,25 @@ const getConfig = () => {
     const envConfig = { ...CONFIG.common, ...CONFIG[env] };
     const finalConfig = {
       ...envConfig,
-      // Deep-merge feature flags so env-specific overrides don't drop common defaults
-      features: {
-        ...CONFIG.common.features || {},
-        ...CONFIG[env] && CONFIG[env].features || {}
-      },
+      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,
-      grafanaUrl: process.env.SYMBOLS_APP_GRAFANA_URL || envConfig.grafanaUrl,
-      typesenseCollectionName: process.env.TYPESENSE_COLLECTION_NAME || envConfig.typesenseCollectionName,
-      typesenseApiKey: process.env.TYPESENSE_API_KEY || envConfig.typesenseApiKey,
-      typesenseHost: process.env.TYPESENSE_HOST || envConfig.typesenseHost,
-      typesensePort: process.env.TYPESENSE_PORT || envConfig.typesensePort,
-      typesenseProtocol: process.env.TYPESENSE_PROTOCOL || envConfig.typesenseProtocol,
-      isDevelopment: (0, import_utils.isDevelopment)(env),
-      isTesting: env === "testing",
+      isDevelopment: env === "development" || env === "local",
       isStaging: env === "staging",
-      isPreview: env === "preview",
       isProduction: env === "production"
-      // Store all environment variables for potential future use
     };
     const requiredFields = [
+      "baseUrl",
       "socketUrl",
       "apiUrl",
+      "basedEnv",
+      "basedProject",
+      "basedOrg",
       "githubClientId",
       "googleClientId"
     ];
@@ -210,19 +129,26 @@ const getConfig = () => {
       );
     }
     if (finalConfig.isDevelopment) {
-      console.warn(
+      console.log(
         "environment in SDK:",
-        env || process.env.NODE_ENV || process.env.NODE_ENV
+        env,
+        "",
+        process.env.SYMBOLS_APP_ENV
       );
       console.log(finalConfig);
-    } else if (global.window) {
-      global.window.finalConfig = finalConfig;
     }
     return finalConfig;
   } catch (error) {
     console.error("Failed to load environment configuration:", error);
     return {
-      ...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",
+      basedOrg: "symbols",
+      githubClientId: "Ov23liHxyWFBxS8f1gnF"
     };
   }
 };