vg-x07df 0.1.0

package/packages/sdk/openapi-ts.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "@hey-api/openapi-ts";
+
+export default defineConfig({
+  input: "http://localhost:3001/doc",
+  output: "./src/generated/api",
+  client: "fetch",
+});

package/packages/sdk/package.json

@@ -0,0 +1,88 @@
+{
+  "name": "vg-x07df",
+  "version": "1.0.2",
+  "description": "Headless SDK for dubadav audio/video",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./livekit": {
+      "types": "./dist/livekit/index.d.ts",
+      "import": "./dist/livekit/index.mjs",
+      "require": "./dist/livekit/index.cjs"
+    }
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "generate:api": "openapi-ts",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "lint": "echo \"Lint not configured - add ESLint setup\"",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run clean && npm run build && npm run typecheck"
+  },
+  "author": "Voyatek Group",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/VoyatekGroup/go-callpad.git",
+    "directory": "web-sdk/packages/sdk"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18",
+    "livekit-client": "^2.8.0",
+    "socket.io-client": "^4.7.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": false
+    },
+    "react-dom": {
+      "optional": false
+    },
+    "livekit-client": {
+      "optional": false
+    },
+    "socket.io-client": {
+      "optional": false
+    }
+  },
+  "dependencies": {
+    "axios": "^1.6.0",
+    "jwt-decode": "^4.0.0",
+    "zustand": "^4.5.0",
+    "immer": "^10.0.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@hey-api/openapi-ts": "^0.37.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.2.0",
+    "@types/react": "^18.2.0",
+    "@types/react-dom": "^18.2.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "livekit-client": "^2.8.0",
+    "socket.io-client": "^4.7.0",
+    "rimraf": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/packages/sdk/src/core/auth.manager.ts

@@ -0,0 +1,52 @@
+import type { AuthProvider, Nullable, JWTPayload } from "./types";
+
+export class AuthManager {
+  private readonly authProvider: AuthProvider;
+  private lastToken: Nullable<string> = null;
+
+  constructor(authProvider: AuthProvider) {
+    this.authProvider = authProvider;
+  }
+
+  getCurrentToken(): string | null {
+    const token = this.authProvider();
+    if (token !== this.lastToken) {
+      this.lastToken = token;
+    }
+
+    return token;
+  }
+
+  /**
+   * Extract user ID from JWT token
+   */
+  getCurrentUserId(): string | null {
+    const token = this.getCurrentToken();
+    if (!token) return null;
+
+    try {
+      const payload = this.decodeJWT(token);
+      return payload?.sub || payload?.userId || payload?.id || null;
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Decode JWT token without verification
+   */
+  private decodeJWT(token: string): JWTPayload | null {
+    const parts = token.split('.');
+    if (parts.length !== 3) return null;
+
+    try {
+      const payload = parts[1]?.replace(/-/g, '+').replace(/_/g, '/');
+      if (!payload) return null;
+      
+      const decodedPayload = JSON.parse(atob(payload));
+      return decodedPayload as JWTPayload;
+    } catch {
+      return null;
+    }
+  }
+}

package/packages/sdk/src/core/events/event-bus.ts

@@ -0,0 +1,301 @@
+/**
+ * SDK Event Bus Implementation
+ *
+ * Provides a centralized event system for internal SDK communication.
+ * Supports type-safe event subscription, filtering, and debugging.
+ */
+
+import { createLogger } from "../../utils/logger";
+import type {
+  EventFilter,
+  EventHandler,
+  EventSubscription,
+  SdkEvent,
+  SdkEventType,
+} from "./types";
+
+const logger = createLogger("core:event-bus");
+
+export class EventBus {
+  private listeners = new Map<string, Set<EventHandler>>();
+  private isDebugMode = false;
+  private eventHistory: SdkEvent[] = [];
+  private maxHistorySize = 100;
+
+  constructor(debugMode = false) {
+    this.isDebugMode = debugMode;
+  }
+
+  /**
+   * Subscribe to events of a specific type
+   */
+  on<T = any>(
+    eventType: string | SdkEventType,
+    handler: EventHandler<T>,
+    filter?: EventFilter<T>
+  ): EventSubscription {
+    const actualHandler = filter
+      ? (event: SdkEvent<T>) => {
+          if (filter(event)) {
+            handler(event);
+          }
+        }
+      : handler;
+
+    if (!this.listeners.has(eventType)) {
+      this.listeners.set(eventType, new Set());
+    }
+
+    this.listeners.get(eventType)?.add(actualHandler);
+
+    if (this.isDebugMode) {
+      logger.debug(`Event listener added for: ${eventType}`, {
+        eventType,
+        totalListeners: this.listeners.get(eventType)?.size,
+      });
+    }
+
+    return {
+      unsubscribe: () => {
+        const handlers = this.listeners.get(eventType);
+        if (handlers) {
+          handlers.delete(actualHandler);
+          if (handlers.size === 0) {
+            this.listeners.delete(eventType);
+          }
+        }
+
+        if (this.isDebugMode) {
+          logger.debug(`Event listener removed for: ${eventType}`, {
+            eventType,
+            remainingListeners: handlers?.size || 0,
+          });
+        }
+      },
+    };
+  }
+
+  /**
+   * Subscribe to events matching a pattern (e.g., "call:*")
+   */
+  onPattern<T = any>(
+    pattern: string,
+    handler: EventHandler<T>,
+    filter?: EventFilter<T>
+  ): EventSubscription {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+    const patternHandler: EventHandler<T> = (event: SdkEvent<T>) => {
+      if (regex.test(event.type)) {
+        if (filter && !filter(event)) return;
+        handler(event);
+      }
+    };
+
+    // Store pattern handlers separately to avoid conflicts
+    const patternKey = `__pattern__${pattern}`;
+    if (!this.listeners.has(patternKey)) {
+      this.listeners.set(patternKey, new Set());
+    }
+
+    this.listeners.get(patternKey)?.add(patternHandler);
+
+    if (this.isDebugMode) {
+      logger.debug(`Pattern listener added: ${pattern}`, { pattern });
+    }
+
+    return {
+      unsubscribe: () => {
+        const handlers = this.listeners.get(patternKey);
+        if (handlers) {
+          handlers.delete(patternHandler);
+          if (handlers.size === 0) {
+            this.listeners.delete(patternKey);
+          }
+        }
+
+        if (this.isDebugMode) {
+          logger.debug(`Pattern listener removed: ${pattern}`, { pattern });
+        }
+      },
+    };
+  }
+
+  /**
+   * Subscribe to a single event occurrence
+   */
+  once<T = any>(
+    eventType: string | SdkEventType,
+    handler: EventHandler<T>,
+    filter?: EventFilter<T>
+  ): EventSubscription {
+    const subscription = this.on(
+      eventType,
+      (event: SdkEvent<T>) => {
+        handler(event);
+        subscription.unsubscribe();
+      },
+      filter
+    );
+
+    return subscription;
+  }
+
+  /**
+   * Emit an event
+   */
+  emit<T = any>(
+    eventType: string | SdkEventType,
+    payload: T,
+    source: "socket" | "livekit" | "user" = "user"
+  ): void {
+    const event: SdkEvent<T> = {
+      type: eventType.toString(),
+      payload,
+      timestamp: Date.now(),
+      source,
+    };
+
+    // Add to history for debugging
+    this.addToHistory(event);
+
+    if (this.isDebugMode) {
+      logger.debug(`Event emitted: ${eventType}`, {
+        eventType,
+        payload,
+        source,
+        timestamp: event.timestamp,
+      });
+    }
+
+    // Emit to exact type listeners
+    const exactListeners = this.listeners.get(eventType.toString());
+    if (exactListeners) {
+      for (const handler of exactListeners) {
+        try {
+          handler(event);
+        } catch (error) {
+          logger.error(`Error in event handler for ${eventType}`, {
+            error,
+            eventType,
+            payload,
+          });
+        }
+      }
+    }
+
+    // Emit to pattern listeners
+    this.listeners.forEach((handlers, key) => {
+      if (key.startsWith("__pattern__")) {
+        for (const handler of handlers) {
+          try {
+            handler(event);
+          } catch (error) {
+            logger.error(`Error in pattern handler for ${eventType}`, {
+              error,
+              eventType,
+              pattern: key,
+              payload,
+            });
+          }
+        }
+      }
+    });
+  }
+
+  /**
+   * Remove all listeners for a specific event type
+   */
+  off(eventType: string | SdkEventType): void {
+    this.listeners.delete(eventType.toString());
+
+    if (this.isDebugMode) {
+      logger.debug(`All listeners removed for: ${eventType}`, { eventType });
+    }
+  }
+
+  /**
+   * Remove all listeners
+   */
+  removeAllListeners(): void {
+    const totalListeners = Array.from(this.listeners.values()).reduce(
+      (sum, handlers) => sum + handlers.size,
+      0
+    );
+
+    this.listeners.clear();
+
+    if (this.isDebugMode) {
+      logger.debug("All listeners removed", { removedCount: totalListeners });
+    }
+  }
+
+  /**
+   * Get the count of listeners for an event type
+   */
+  listenerCount(eventType: string | SdkEventType): number {
+    return this.listeners.get(eventType.toString())?.size || 0;
+  }
+
+  /**
+   * Get all event types that have listeners
+   */
+  getEventTypes(): string[] {
+    return Array.from(this.listeners.keys());
+  }
+
+  /**
+   * Enable or disable debug mode
+   */
+  setDebugMode(enabled: boolean): void {
+    this.isDebugMode = enabled;
+    logger.debug(`Debug mode ${enabled ? "enabled" : "disabled"}`);
+  }
+
+  /**
+   * Get event history for debugging
+   */
+  getEventHistory(): SdkEvent[] {
+    return [...this.eventHistory];
+  }
+
+  /**
+   * Clear event history
+   */
+  clearHistory(): void {
+    this.eventHistory = [];
+    if (this.isDebugMode) {
+      logger.debug("Event history cleared");
+    }
+  }
+
+  /**
+   * Get events matching a filter
+   */
+  getEventsWhere(filter: EventFilter): SdkEvent[] {
+    return this.eventHistory.filter(filter);
+  }
+
+  private addToHistory(event: SdkEvent): void {
+    this.eventHistory.push(event);
+
+    // Keep history size manageable
+    if (this.eventHistory.length > this.maxHistorySize) {
+      this.eventHistory.shift();
+    }
+  }
+
+  /**
+   * Set maximum history size
+   */
+  setMaxHistorySize(size: number): void {
+    this.maxHistorySize = size;
+
+    // Trim existing history if needed
+    if (this.eventHistory.length > size) {
+      this.eventHistory = this.eventHistory.slice(-size);
+    }
+  }
+}
+
+// Global event bus instance
+export const eventBus = new EventBus(false);

package/packages/sdk/src/core/events/index.ts

@@ -0,0 +1,8 @@
+/**
+ * SDK Event System
+ *
+ * Exports the event bus and event types for internal SDK use.
+ */
+
+export { EventBus, eventBus } from "./event-bus";
+export * from "./types";

package/packages/sdk/src/core/events/types.ts

@@ -0,0 +1,165 @@
+/**
+ * SDK Event System Types
+ *
+ * This file defines the event types and interfaces for the internal SDK event system.
+ * The event system provides extensibility and allows components to communicate
+ * through a unified, type-safe event bus.
+ */
+
+export interface SdkEvent<T = any> {
+  type: string;
+  payload: T;
+  timestamp: number;
+  source: "socket" | "livekit" | "user";
+}
+
+/**
+ * SDK Event Types
+ * Following the pattern from other WebRTC SDKs like LiveKit
+ */
+export enum SdkEventType {
+  // Call lifecycle events
+  CALL_INITIATED = "call:initiated",
+  CALL_INCOMING = "call:incoming",
+  CALL_ACCEPTED = "call:accepted",
+  CALL_DECLINED = "call:declined",
+  CALL_ENDED = "call:ended",
+  CALL_CANCELED = "call:canceled",
+  CALL_TIMEOUT = "call:timeout",
+  JOIN_INFO_RECEIVED = "join-info:received",
+
+  // Participant events
+  PARTICIPANT_JOINING = "participant:joining",
+  PARTICIPANT_JOINED = "participant:joined",
+  PARTICIPANT_LEFT = "participant:left",
+  PARTICIPANT_UPDATED = "participant:updated",
+
+  // Media events
+  MEDIA_ENABLED = "media:enabled",
+  MEDIA_DISABLED = "media:disabled",
+  MEDIA_DEVICE_CHANGED = "media:device-changed",
+  MEDIA_PERMISSION_GRANTED = "media:permission-granted",
+  MEDIA_PERMISSION_DENIED = "media:permission-denied",
+
+  // Connection events
+  CONNECTION_ESTABLISHED = "connection:established",
+  CONNECTION_LOST = "connection:lost",
+  CONNECTION_RECONNECTING = "connection:reconnecting",
+  CONNECTION_QUALITY_CHANGED = "connection:quality-changed",
+
+  // Error events
+  ERROR_OCCURRED = "error:occurred",
+}
+
+/**
+ * Specific event payload types
+ */
+export interface CallInitiatedEvent {
+  callId: string;
+  participants: string[];
+  type: "AUDIO" | "VIDEO";
+  timestamp: number;
+}
+
+export interface CallIncomingEvent {
+  callId: string;
+  caller: {
+    id: string;
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+  };
+  type: "AUDIO" | "VIDEO";
+  timestamp: number;
+}
+
+export interface CallAcceptedEvent {
+  callId: string;
+  participantId: string;
+  timestamp: number;
+}
+
+export interface CallDeclinedEvent {
+  callId: string;
+  participantId: string;
+  reason?: string;
+  timestamp: number;
+}
+
+export interface CallEndedEvent {
+  callId: string;
+  endedBy?: string;
+  reason?: "user" | "timeout" | "error";
+  timestamp: number;
+}
+
+export interface JoinInfoReceivedEvent {
+  callId: string;
+  participantId: string;
+  timestamp: number;
+  hasUrl: boolean;
+  hasToken: boolean;
+  autoJoined?: boolean;
+}
+
+export interface ParticipantJoinedEvent {
+  callId: string;
+  participant: {
+    id: string;
+    firstName?: string;
+    lastName?: string;
+    avatarUrl?: string;
+    role: "CALLER" | "CALLEE" | "HOST" | "MEMBER";
+  };
+  timestamp: number;
+}
+
+export interface ParticipantLeftEvent {
+  callId: string;
+  participantId: string;
+  reason?: "user" | "timeout" | "error";
+  timestamp: number;
+}
+
+export interface MediaEnabledEvent {
+  participantId: string;
+  mediaType: "audio" | "video" | "screen";
+  timestamp: number;
+}
+
+export interface MediaDisabledEvent {
+  participantId: string;
+  mediaType: "audio" | "video" | "screen";
+  timestamp: number;
+}
+
+export interface ConnectionQualityChangedEvent {
+  participantId: string;
+  quality: "excellent" | "good" | "poor" | "lost";
+  timestamp: number;
+}
+
+export interface ErrorOccurredEvent {
+  code: string;
+  message: string;
+  details?: any;
+  source: "socket" | "livekit" | "user";
+  timestamp: number;
+}
+
+/**
+ * Event handler type
+ */
+export type EventHandler<T = any> = (event: SdkEvent<T>) => void;
+
+/**
+ * Event subscription interface
+ */
+export interface EventSubscription {
+  unsubscribe: () => void;
+}
+
+/**
+ * Event filter function type
+ */
+export type EventFilter<T = any> = (event: SdkEvent<T>) => boolean;

package/packages/sdk/src/core/index.ts

@@ -0,0 +1,3 @@
+export { AuthManager } from "./auth.manager";
+export { SocketManager } from "./socketio";
+export * from "./types";

package/packages/sdk/src/core/signal/api.config.ts

@@ -0,0 +1,49 @@
+import { OpenAPI } from "../../generated/api";
+import type { ApiConfig } from "./types";
+
+export class OpenApiConfigService {
+  private static instance: OpenApiConfigService;
+
+  private constructor() {}
+
+  static getInstance(): OpenApiConfigService {
+    if (!OpenApiConfigService.instance) {
+      OpenApiConfigService.instance = new OpenApiConfigService();
+    }
+    return OpenApiConfigService.instance;
+  }
+
+  configure(config: ApiConfig): void {
+    OpenAPI.BASE = config.baseUrl;
+
+    // Handle token - OpenAPI expects string | Resolver<string>
+    // Resolver<string> = (options: ApiRequestOptions) => Promise<string>
+    if (typeof config.token === "function") {
+      const tokenFn = config.token; // Capture the function reference
+      OpenAPI.TOKEN = async (_options) => {
+        const result = tokenFn();
+        return typeof result === "string" ? result : await result;
+      };
+    } else {
+      OpenAPI.TOKEN = config.token;
+    }
+
+    OpenAPI.CREDENTIALS = config.credentials ?? "include";
+    OpenAPI.WITH_CREDENTIALS = config.withCredentials ?? false;
+
+    if (config.headers) {
+      OpenAPI.HEADERS = config.headers;
+    }
+  }
+
+  setToken(token: string): void {
+    OpenAPI.TOKEN = token;
+  }
+}
+
+export const apiConfig = OpenApiConfigService.getInstance();
+
+export { OpenAPI };
+
+// Re-export ApiConfig type
+export type { ApiConfig } from "./types";

package/packages/sdk/src/core/signal/index.ts

@@ -0,0 +1,16 @@
+export { SignalClient } from "./signal.client";
+export { apiConfig } from "./api.config";
+export type {
+  SignalClientConfig,
+  CallInfo,
+  CallParticipant,
+  LiveKitJoinInfo,
+  IncomingCallEvent,
+  CallState,
+  CallMode,
+  EndReason,
+  ApiConfig,
+} from "./types";
+export * from "./types";
+// Re-export the generated API response type for convenience
+export type { CallsData } from "../../generated/api/models";