@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/node/services/WaitlistService.js

@@ -0,0 +1,129 @@
+import { BaseService } from "./BaseService.js";
+class WaitlistService extends BaseService {
+  // ==================== WAITLIST METHODS ====================
+  /**
+   * Join a waitlist campaign (public).
+   *
+   * Mirrors: POST /waitlist (WaitlistController.join)
+   */
+  async joinWaitlist(data = {}) {
+    this._requireReady("joinWaitlist");
+    if (!data || typeof data !== "object") {
+      throw new Error("Waitlist join payload is required");
+    }
+    if (!data.email) {
+      throw new Error("Email is required");
+    }
+    try {
+      const response = await this._request("/waitlist", {
+        method: "POST",
+        body: JSON.stringify(data),
+        methodName: "joinWaitlist"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to join waitlist: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List waitlist entries (admin).
+   *
+   * Mirrors: GET /waitlist (WaitlistController.list)
+   */
+  async listWaitlistEntries(options = {}) {
+    this._requireReady("listWaitlistEntries");
+    const {
+      campaignKey,
+      status,
+      search,
+      page,
+      limit
+    } = options || {};
+    const queryParams = new URLSearchParams();
+    if (campaignKey != null) {
+      queryParams.append("campaignKey", String(campaignKey));
+    }
+    if (status != null) {
+      queryParams.append("status", String(status));
+    }
+    if (search != null) {
+      queryParams.append("search", String(search));
+    }
+    if (page != null) {
+      queryParams.append("page", String(page));
+    }
+    if (limit != null) {
+      queryParams.append("limit", String(limit));
+    }
+    const queryString = queryParams.toString();
+    const url = `/waitlist${queryString ? `?${queryString}` : ""}`;
+    try {
+      const response = await this._request(url, {
+        method: "GET",
+        methodName: "listWaitlistEntries"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list waitlist entries: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Update a waitlist entry (admin).
+   *
+   * Mirrors: PATCH /waitlist/:id (WaitlistController.update)
+   */
+  async updateWaitlistEntry(id, update = {}) {
+    this._requireReady("updateWaitlistEntry");
+    if (!id) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    if (!update || typeof update !== "object") {
+      throw new Error("Update payload is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id}`, {
+        method: "PATCH",
+        body: JSON.stringify(update),
+        methodName: "updateWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to update waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Send an invitation email for a waitlist entry (admin).
+   *
+   * Mirrors: POST /waitlist/:id/invite (WaitlistController.invite)
+   */
+  async inviteWaitlistEntry(id) {
+    this._requireReady("inviteWaitlistEntry");
+    if (!id) {
+      throw new Error("Waitlist entry ID is required");
+    }
+    try {
+      const response = await this._request(`/waitlist/${id}/invite`, {
+        method: "POST",
+        methodName: "inviteWaitlistEntry"
+      });
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to invite waitlist entry: ${error.message}`, { cause: error });
+    }
+  }
+}
+export {
+  WaitlistService
+};

package/dist/node/services/index.js

@@ -1,23 +1,71 @@
-import { SymstoryService } from "./SymstoryService.js";
 import { AuthService } from "./AuthService.js";
-import { AIService } from "./AIService.js";
-import { SocketService } from "./SocketIOService.js";
-import { CoreService } from "./CoreService.js";
+import { CollabService } from "./CollabService.js";
+import { ProjectService } from "./ProjectService.js";
+import { PlanService } from "./PlanService.js";
+import { SubscriptionService } from "./SubscriptionService.js";
+import { FileService } from "./FileService.js";
+import { PaymentService } from "./PaymentService.js";
+import { DnsService } from "./DnsService.js";
+import { BranchService } from "./BranchService.js";
+import { PullRequestService } from "./PullRequestService.js";
+import { AdminService } from "./AdminService.js";
+import { ScreenshotService } from "./ScreenshotService.js";
+import { TrackingService } from "./TrackingService.js";
+import { WaitlistService } from "./WaitlistService.js";
+import { MetricsService } from "./MetricsService.js";
+import { IntegrationService } from "./IntegrationService.js";
+import { FeatureFlagService } from "./FeatureFlagService.js";
 const createService = (ServiceClass, config) => new ServiceClass(config);
-const createSymstoryService = (config) => createService(SymstoryService, config);
 const createAuthService = (config) => createService(AuthService, config);
-const createAIService = (config) => createService(AIService, config);
-const createSocketService = (config) => createService(SocketService, config);
-const createCoreService = (config) => createService(CoreService, config);
+const createCollabService = (config) => createService(CollabService, config);
+const createProjectService = (config) => createService(ProjectService, config);
+const createPlanService = (config) => createService(PlanService, config);
+const createSubscriptionService = (config) => createService(SubscriptionService, config);
+const createFileService = (config) => createService(FileService, config);
+const createPaymentService = (config) => createService(PaymentService, config);
+const createDnsService = (config) => createService(DnsService, config);
+const createBranchService = (config) => createService(BranchService, config);
+const createPullRequestService = (config) => createService(PullRequestService, config);
+const createAdminService = (config) => createService(AdminService, config);
+const createScreenshotService = (config) => createService(ScreenshotService, config);
+const createTrackingService = (config) => createService(TrackingService, config);
+const createWaitlistService = (config) => createService(WaitlistService, config);
+const createMetricsService = (config) => createService(MetricsService, config);
+const createIntegrationService = (config) => createService(IntegrationService, config);
+const createFeatureFlagService = (config) => createService(FeatureFlagService, config);
 export {
-  AIService,
+  AdminService,
   AuthService,
-  CoreService,
-  SocketService,
-  SymstoryService,
-  createAIService,
+  BranchService,
+  CollabService,
+  DnsService,
+  FeatureFlagService,
+  FileService,
+  IntegrationService,
+  MetricsService,
+  PaymentService,
+  PlanService,
+  ProjectService,
+  PullRequestService,
+  ScreenshotService,
+  SubscriptionService,
+  TrackingService,
+  WaitlistService,
+  createAdminService,
   createAuthService,
-  createCoreService,
-  createSocketService,
-  createSymstoryService
+  createBranchService,
+  createCollabService,
+  createDnsService,
+  createFeatureFlagService,
+  createFileService,
+  createIntegrationService,
+  createMetricsService,
+  createPaymentService,
+  createPlanService,
+  createProjectService,
+  createPullRequestService,
+  createScreenshotService,
+  createSubscriptionService,
+  createTrackingService,
+  createWaitlistService
 };

package/dist/node/state/RootStateManager.js

@@ -0,0 +1,36 @@
+import * as utils from "@domql/utils";
+import { rootBus } from "./rootEventBus.js";
+const { isFunction } = utils.default || utils;
+class RootStateManager {
+  constructor(rootState) {
+    this._rootState = rootState;
+  }
+  /**
+   * Apply change tuples to the root state using the built-in setPathCollection
+   * of Symbo.ls APP state tree.
+   *
+   * @param {Array} changes – eg. ['update', ['foo'], 'bar']
+   * @param {Object} opts   – forwarded to setPathCollection
+   */
+  async applyChanges(changes = [], opts = {}) {
+    if (!this._rootState || !isFunction(this._rootState.setPathCollection)) {
+      return;
+    }
+    const result = await this._rootState.setPathCollection(changes, {
+      preventUpdate: true,
+      ...opts
+    });
+    return result;
+  }
+  setVersion(v) {
+    if (this._rootState) {
+      this._rootState.version = v;
+    }
+  }
+  get root() {
+    return this._rootState;
+  }
+}
+export {
+  RootStateManager
+};

package/dist/node/state/rootEventBus.js

@@ -0,0 +1,55 @@
+const getGlobalBus = () => {
+  if (globalThis.__SMBLS_ROOT_BUS__) {
+    return globalThis.__SMBLS_ROOT_BUS__;
+  }
+  const events = {};
+  const lastPayloads = {};
+  const bus = {
+    on(event, handler) {
+      (events[event] ||= []).push(handler);
+      if (Object.hasOwn(lastPayloads, event)) {
+        try {
+          handler(lastPayloads[event]);
+        } catch (err) {
+          console.error("[rootBus] handler error for (replay)", event, err);
+        }
+      }
+    },
+    off(event, handler) {
+      const list = events[event];
+      if (!list) {
+        return;
+      }
+      const idx = list.indexOf(handler);
+      if (idx !== -1) {
+        list.splice(idx, 1);
+      }
+    },
+    emit(event, payload) {
+      lastPayloads[event] = payload;
+      const list = events[event];
+      if (!list || !list.length) {
+        return;
+      }
+      list.slice().forEach((fn) => {
+        try {
+          fn(payload);
+        } catch (err) {
+          console.error("[rootBus] handler error for", event, err);
+        }
+      });
+    }
+  };
+  Object.defineProperty(bus, "_listeners", {
+    value: events,
+    enumerable: false
+  });
+  globalThis.__SMBLS_ROOT_BUS__ = bus;
+  return bus;
+};
+const rootBus = getGlobalBus();
+var rootEventBus_default = rootBus;
+export {
+  rootEventBus_default as default,
+  rootBus
+};

package/dist/node/utils/CollabClient.js

@@ -0,0 +1,194 @@
+import { io } from "socket.io-client";
+import * as Y from "yjs";
+import { nanoid } from "nanoid";
+import environment from "../config/environment.js";
+import { diffJson, applyOpsToJson } from "./jsonDiff.js";
+class CollabClient {
+  /* public fields */
+  socket = null;
+  ydoc = null;
+  branch = "main";
+  live = false;
+  projectId = null;
+  jwt = null;
+  /* private state */
+  _buffer = [];
+  _flushTimer = null;
+  _clientId = nanoid();
+  _outboxStore = createMemoryOutbox();
+  // Dexie table fallback
+  _readyResolve;
+  ready = new Promise((res) => this._readyResolve = res);
+  constructor({ jwt, projectId, branch = "main", live = false }) {
+    Object.assign(this, { jwt, projectId, branch, live });
+    this.ydoc = new Y.Doc();
+    const hasIndexedDB = typeof globalThis.indexedDB !== "undefined";
+    if (typeof window === "undefined" || !hasIndexedDB) {
+      console.log("[CollabClient] IndexedDB not available \u2013 skipping offline persistence");
+    } else {
+      import("y-indexeddb").then(({ IndexeddbPersistence }) => {
+        new IndexeddbPersistence(`${projectId}:${branch}`, this.ydoc);
+      }).catch((err) => {
+        console.warn("[CollabClient] Failed to load IndexeddbPersistence:", err);
+      });
+    }
+    if (typeof window !== "undefined" && hasIndexedDB) {
+      createDexieOutbox(`${projectId}:${branch}`).then((outboxStore) => {
+        this._outboxStore = outboxStore;
+      }).catch((err) => {
+        console.warn("[CollabClient] Failed to load Dexie:", err);
+      });
+    }
+    this.socket = io(environment.socketUrl, {
+      path: "/collab-socket",
+      transports: ["websocket"],
+      auth: { token: jwt, projectId, branch, live },
+      reconnectionAttempts: Infinity,
+      reconnectionDelayMax: 4e3
+    });
+    this.socket.on("snapshot", this._onSnapshot).on("ops", this._onOps).on("commit", this._onCommit).on("liveMode", this._onLiveMode).on("connect", this._onConnect).on("error", this._onError);
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    this.ydoc.on("afterTransaction", (tr) => {
+      if (tr.origin === "remote") {
+        return;
+      }
+      const currentJson = this.ydoc.getMap("root").toJSON();
+      const ops = diffJson(this._prevJson, currentJson);
+      this._prevJson = currentJson;
+      if (!ops.length) {
+        return;
+      }
+      this._queueOps(ops);
+    });
+  }
+  /* ---------- public helpers ---------- */
+  toggleLive(flag) {
+    this.socket.emit("toggleLive", Boolean(flag));
+  }
+  sendCursor(data) {
+    this.socket.emit("cursor", data);
+  }
+  sendPresence(d) {
+    this.socket.emit("presence", d);
+  }
+  /* ---------- private handlers ---------- */
+  _onSnapshot = ({
+    data
+    /* Uint8Array */
+  }) => {
+    if (Array.isArray(data) ? data.length : data && data.byteLength) {
+      Y.applyUpdate(this.ydoc, Uint8Array.from(data));
+    } else {
+      console.warn("[collab] Received empty snapshot \u2013 skipping applyUpdate");
+    }
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  };
+  _onOps = ({ changes }) => {
+    applyOpsToJson(changes, this.ydoc);
+    this._prevJson = this.ydoc.getMap("root").toJSON();
+  };
+  _onCommit = async ({ version }) => {
+    await this._outboxStore.clear();
+    console.info("[collab] committed", version);
+  };
+  _onConnect = async () => {
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+    const queued = await this._outboxStore.toArray();
+    if (queued.length) {
+      this.socket.emit("ops", {
+        changes: queued.flatMap((e) => e.ops),
+        ts: Date.now(),
+        clientId: this._clientId
+      });
+      await this._outboxStore.clear();
+    }
+  };
+  /* ---------- buffering & debounce ---------- */
+  _queueOps(ops) {
+    this._buffer.push(...ops);
+    this._outboxStore.put({ id: nanoid(), ops });
+    if (this.live && this.socket.connected) {
+      this._flushNow();
+    } else {
+      clearTimeout(this._flushTimer);
+      this._flushTimer = setTimeout(() => this._flushNow(), 40);
+    }
+  }
+  _flushNow() {
+    if (!this._buffer.length || !this.socket.connected) {
+      return;
+    }
+    this.socket.emit("ops", {
+      changes: this._buffer,
+      ts: Date.now(),
+      clientId: this._clientId
+    });
+    this._buffer.length = 0;
+  }
+  dispose() {
+    var _a;
+    clearTimeout(this._flushTimer);
+    this._flushTimer = null;
+    this._buffer.length = 0;
+    if ((_a = this._outboxStore) == null ? void 0 : _a.clear) {
+      try {
+        const result = this._outboxStore.clear();
+        if (result && typeof result.catch === "function") {
+          result.catch(() => {
+          });
+        }
+      } catch (error) {
+        console.warn("[CollabClient] Failed to clear outbox store during dispose:", error);
+      }
+    }
+    if (this.socket) {
+      this.socket.off("snapshot", this._onSnapshot);
+      this.socket.off("ops", this._onOps);
+      this.socket.off("commit", this._onCommit);
+      this.socket.off("liveMode", this._onLiveMode);
+      this.socket.off("connect", this._onConnect);
+      this.socket.off("error", this._onError);
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    if (this.ydoc) {
+      this.ydoc.destroy();
+      this.ydoc = null;
+    }
+    if (typeof this._readyResolve === "function") {
+      this._readyResolve();
+      this._readyResolve = null;
+    }
+  }
+  _onLiveMode = (flag) => {
+    this.live = flag;
+  };
+  _onError = (e) => {
+    console.warn("[collab] socket error", e);
+  };
+}
+function createMemoryOutbox() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    put: (item) => store.set(item.id, item),
+    toArray: () => Array.from(store.values()),
+    clear: () => store.clear()
+  };
+}
+async function createDexieOutbox(name) {
+  const { default: Dexie } = await import("dexie");
+  const db = new Dexie(`collab-${name}`);
+  db.version(1).stores({ outbox: "id, ops" });
+  return db.table("outbox");
+}
+export {
+  CollabClient
+};

package/dist/node/utils/TokenManager.js

@@ -2,7 +2,7 @@ class TokenManager {
   constructor(options = {}) {
     this.config = {
       storagePrefix: "symbols_",
-      storageType: "localStorage",
+      storageType: typeof window === "undefined" || process.env.NODE_ENV === "test" || process.env.NODE_ENV === "testing" ? "memory" : "localStorage",
       // 'localStorage' | 'sessionStorage' | 'memory'
       refreshBuffer: 60 * 1e3,
       // Refresh 1 minute before expiry
@@ -42,13 +42,26 @@ class TokenManager {
     if (typeof window === "undefined") {
       return this._memoryStorage;
     }
+    const safeGetStorage = (provider) => {
+      try {
+        const storage = provider();
+        const testKey = `${this.config.storagePrefix}__tm_test__`;
+        storage.setItem(testKey, "1");
+        storage.removeItem(testKey);
+        return storage;
+      } catch {
+        return null;
+      }
+    };
+    const localStorageInstance = safeGetStorage(() => window.localStorage);
+    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage);
     switch (this.config.storageType) {
       case "sessionStorage":
-        return window.sessionStorage;
+        return sessionStorageInstance || this._memoryStorage;
       case "memory":
         return this._memoryStorage;
       default:
-        return window.localStorage;
+        return localStorageInstance || this._memoryStorage;
     }
   }
   /**
@@ -129,7 +142,28 @@ class TokenManager {
       return true;
     }
     const now = Date.now();
-    return now < this.tokens.expiresAt - this.config.refreshBuffer;
+    const isValid = now < this.tokens.expiresAt - this.config.refreshBuffer;
+    if (!isValid) {
+      console.log("[TokenManager] Access token is expired or near expiry:", {
+        now: new Date(now).toISOString(),
+        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
+        refreshBuffer: this.config.refreshBuffer
+      });
+    }
+    return isValid;
+  }
+  /**
+   * Check if access token exists and is not expired (without refresh buffer)
+   */
+  isAccessTokenActuallyValid() {
+    if (!this.tokens.accessToken) {
+      return false;
+    }
+    if (!this.tokens.expiresAt) {
+      return true;
+    }
+    const now = Date.now();
+    return now < this.tokens.expiresAt;
   }
   /**
    * Check if tokens exist (regardless of expiry)
@@ -255,40 +289,54 @@ class TokenManager {
    * Save tokens to storage
    */
   saveTokens() {
-    const { storage } = this;
-    const keys = this.storageKeys;
-    if (this.tokens.accessToken) {
-      storage.setItem(keys.accessToken, this.tokens.accessToken);
-    }
-    if (this.tokens.refreshToken) {
-      storage.setItem(keys.refreshToken, this.tokens.refreshToken);
-    }
-    if (this.tokens.expiresAt) {
-      storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
-    }
-    if (this.tokens.expiresIn) {
-      storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
+    try {
+      const { storage } = this;
+      const keys = this.storageKeys;
+      if (this.tokens.accessToken) {
+        storage.setItem(keys.accessToken, this.tokens.accessToken);
+      }
+      if (this.tokens.refreshToken) {
+        storage.setItem(keys.refreshToken, this.tokens.refreshToken);
+      }
+      if (this.tokens.expiresAt) {
+        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
+      }
+      if (this.tokens.expiresIn) {
+        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
+      }
+    } catch (error) {
+      console.error("[TokenManager] Error saving tokens to storage:", error);
     }
   }
   /**
    * Load tokens from storage
    */
   loadTokens() {
-    const { storage } = this;
-    const keys = this.storageKeys;
-    const accessToken = storage.getItem(keys.accessToken);
-    const refreshToken = storage.getItem(keys.refreshToken);
-    const expiresAt = storage.getItem(keys.expiresAt);
-    const expiresIn = storage.getItem(keys.expiresIn);
-    if (accessToken) {
+    try {
+      const { storage } = this;
+      const keys = this.storageKeys;
+      const accessToken = storage.getItem(keys.accessToken);
+      const refreshToken = storage.getItem(keys.refreshToken);
+      const expiresAt = storage.getItem(keys.expiresAt);
+      const expiresIn = storage.getItem(keys.expiresIn);
+      if (accessToken) {
+        this.tokens = {
+          accessToken,
+          refreshToken,
+          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
+          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
+          tokenType: "Bearer"
+        };
+        this.scheduleRefresh();
+      }
+    } catch (error) {
+      console.error("[TokenManager] Error loading tokens from storage:", error);
       this.tokens = {
-        accessToken,
-        refreshToken,
-        expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-        expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-        tokenType: "Bearer"
+        accessToken: null,
+        refreshToken: null,
+        expiresAt: null,
+        expiresIn: null
       };
-      this.scheduleRefresh();
     }
   }
   /**