@logspace/sdk 1.0.0

package/shared/types.d.ts

@@ -0,0 +1,356 @@
+export interface RecordingSession {
+    id: string;
+    startTime: number;
+    endTime?: number;
+    duration: number;
+    tabs: TabRecording[];
+    settings: RecordingSettings;
+    status: 'active' | 'paused' | 'stopped';
+    totalSize: number;
+    stats: SessionStats;
+    cspBlocked?: boolean;
+    title?: string;
+    comment?: string;
+}
+export interface TabRecording {
+    tabId: number;
+    url: string;
+    title: string;
+    logs?: LogEntry[];
+    interactions?: InteractionLog[];
+    pageMetrics: PageMetrics;
+    startTime: number;
+    endTime?: number;
+}
+export type LogType = 'network' | 'console' | 'error' | 'interaction' | 'performance' | 'annotation' | 'websocket' | 'sse' | 'storage';
+export interface LogEntry {
+    id: string;
+    timestamp: number;
+    type: LogType;
+    tabId: number;
+    tabUrl: string;
+    data: any;
+    severity?: 'info' | 'warn' | 'error';
+}
+export interface NetworkLog extends LogEntry {
+    type: 'network';
+    data: {
+        method: string;
+        url: string;
+        status: number;
+        statusText?: string;
+        requestHeaders: Record<string, string>;
+        responseHeaders: Record<string, string>;
+        requestBody?: string;
+        responseBody?: string;
+        contentType?: string;
+        contentLength?: number;
+        duration: number;
+        timestamp: number;
+        initiator?: string;
+        error?: string;
+        isWebSocketUpgrade?: boolean;
+        isSSEStream?: boolean;
+    };
+}
+export interface ConsoleLog extends LogEntry {
+    type: 'console';
+    data: {
+        level: 'log' | 'info' | 'warn' | 'error' | 'debug';
+        args: string[];
+        stackTrace?: string;
+    };
+}
+export interface ErrorLog extends LogEntry {
+    type: 'error';
+    data: {
+        message: string;
+        stack: string;
+        context: Record<string, any>;
+        isUncaught: boolean;
+    };
+}
+export interface InteractionLog extends LogEntry {
+    type: 'interaction';
+    data: {
+        eventType: 'click' | 'input' | 'change' | 'scroll' | 'submit';
+        element: {
+            selector: string;
+            tagName: string;
+            text?: string;
+        };
+        coordinates?: {
+            x: number;
+            y: number;
+        };
+        value?: string;
+    };
+}
+export interface PerformanceLog extends LogEntry {
+    type: 'performance';
+    data: {
+        metric: string;
+        value?: number;
+        rating?: 'good' | 'needs-improvement' | 'poor';
+        vitals?: {
+            LCP?: {
+                value: number;
+                rating: string;
+            };
+            FID?: {
+                value: number;
+                rating: string;
+            };
+            CLS?: {
+                value: number;
+                rating: string;
+            };
+            FCP?: {
+                value: number;
+                rating: string;
+            };
+            TTFB?: {
+                value: number;
+                rating: string;
+            };
+            INP?: {
+                value: number;
+                rating: string;
+            };
+        };
+        timing?: {
+            ttfb?: number;
+            dnsLookup?: number;
+            tcpConnection?: number;
+            domContentLoaded?: number;
+            pageLoad?: number;
+        };
+    };
+}
+export type AnnotationType = 'success' | 'issue' | 'important' | 'note' | 'draw';
+export interface AnnotationLog extends LogEntry {
+    type: 'annotation';
+    data: {
+        text: string;
+        annotationType: AnnotationType;
+        coordinates?: {
+            x: number;
+            y: number;
+        };
+        drawing?: {
+            strokes: Array<{
+                points: Array<{
+                    x: number;
+                    y: number;
+                }>;
+                color: string;
+                width: number;
+            }>;
+        };
+    };
+}
+export interface DrawingAnnotation {
+    id: string;
+    sessionId: string;
+    timestamp: number;
+    strokes: Array<{
+        points: Array<{
+            x: number;
+            y: number;
+        }>;
+        color: string;
+        width: number;
+    }>;
+}
+export interface WebSocketLog extends LogEntry {
+    type: 'websocket';
+    data: {
+        url: string;
+        event: 'open' | 'message' | 'error' | 'close';
+        direction?: 'sent' | 'received';
+        message?: string;
+        messageSize?: number;
+        isBinary?: boolean;
+        code?: number;
+        reason?: string;
+        readyState?: number;
+        timestamp: number;
+    };
+}
+export interface SSELog extends LogEntry {
+    type: 'sse';
+    data: {
+        url: string;
+        event: 'open' | 'message' | 'error';
+        eventType?: string;
+        message?: string;
+        messageSize?: number;
+        lastEventId?: string;
+        readyState?: number;
+        timestamp: number;
+    };
+}
+export interface StorageLog extends LogEntry {
+    type: 'storage';
+    data: {
+        storageType: 'localStorage' | 'sessionStorage' | 'indexedDB';
+        operation: 'setItem' | 'getItem' | 'removeItem' | 'clear';
+        key?: string;
+        value?: string;
+        oldValue?: string;
+        valueSize?: number;
+        dbName?: string;
+        storeName?: string;
+    };
+}
+export type CaptureMode = 'auto' | 'fullscreen' | 'custom';
+export type LogSeverity = 'log' | 'info' | 'warn' | 'error' | 'debug' | 'trace';
+export interface RecordingSettings {
+    captureVideo: boolean;
+    captureMode: CaptureMode;
+    captureNetwork: boolean;
+    captureConsole: boolean;
+    captureStorage: boolean;
+    captureResources: boolean;
+    captureInteractions: boolean;
+    capturePerformance: boolean;
+    captureWebSocket: boolean;
+    captureSSE: boolean;
+    captureAnnotations: boolean;
+    showAnnotationButton: boolean;
+    annotationButtonPosition: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    showSpaceIndicator: boolean;
+    videoQuality: 'low' | 'medium' | 'high';
+    videoCodec: 'vp8' | 'vp9' | 'h264';
+    frameRate: number;
+    audioEnabled: boolean;
+    captureMicrophone: boolean;
+    captureSystemAudio: boolean;
+    captureWebcam: boolean;
+    webcamPosition: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+    webcamSize: 'small' | 'medium' | 'large';
+    showCountdown: boolean;
+    excludeDomains: string[];
+    maskSensitiveData: boolean;
+    logLevels: LogSeverity[];
+}
+export declare const DEFAULT_SETTINGS: RecordingSettings;
+export interface SessionStats {
+    logCount: number;
+    networkLogCount: number;
+    consoleLogCount: number;
+    errorCount: number;
+    storageLogCount: number;
+    interactionLogCount: number;
+    performanceLogCount: number;
+    annotationCount: number;
+    tabCount: number;
+}
+export interface PageMetrics {
+    loadTime: number;
+    domContentLoaded: number;
+    firstContentfulPaint?: number;
+    largestContentfulPaint?: number;
+    cumulativeLayoutShift?: number;
+    firstInputDelay?: number;
+}
+export interface TabContext {
+    tabId: number;
+    url: string;
+    title: string;
+    startTime: number;
+    endTime?: number;
+}
+export interface TimelineEvent {
+    timestamp: number;
+    type: 'tab_open' | 'tab_close' | 'navigation' | 'error' | 'interaction';
+    tabId: number;
+    description: string;
+}
+export interface AggregatedLogs {
+    sessionId: string;
+    logs: LogEntry[];
+    tabContexts: Map<number, TabContext>;
+    timelineEvents: TimelineEvent[];
+}
+export interface ExportData {
+    sessionId: string;
+    startTime: number;
+    duration: number;
+    tabs: ExportedTab[];
+    metadata: Record<string, any>;
+}
+export interface ExportedTab {
+    tabId: number;
+    url: string;
+    logs: LogEntry[];
+    interactions: InteractionLog[];
+    pageMetrics: PageMetrics;
+}
+export declare enum MessageType {
+    START_RECORDING = "START_RECORDING",
+    STOP_RECORDING = "STOP_RECORDING",
+    DISCARD_RECORDING = "DISCARD_RECORDING",
+    PAUSE_RECORDING = "PAUSE_RECORDING",
+    RESUME_RECORDING = "RESUME_RECORDING",
+    LOG_ENTRY = "LOG_ENTRY",
+    GET_STATUS = "GET_STATUS",
+    REGISTER_TAB = "REGISTER_TAB",
+    UNREGISTER_TAB = "UNREGISTER_TAB",
+    CSP_DETECTED = "CSP_DETECTED",// CSP blocked script injection
+    FETCH_ASSIGNED_LOGS = "FETCH_ASSIGNED_LOGS"
+}
+export interface Message {
+    type: MessageType;
+    payload?: any;
+}
+export interface StartRecordingMessage extends Message {
+    type: MessageType.START_RECORDING;
+    payload: {
+        settings: RecordingSettings;
+    };
+}
+export interface LogEntryMessage extends Message {
+    type: MessageType.LOG_ENTRY;
+    payload: {
+        sessionId: string;
+        tabId: number;
+        log: LogEntry;
+    };
+}
+export interface StatusResponse {
+    isRecording: boolean;
+    session: RecordingSession | null;
+    error?: string;
+    auth?: AuthState;
+}
+export interface CspDetectedMessage extends Message {
+    type: MessageType.CSP_DETECTED;
+    payload: {
+        url: string;
+    };
+}
+export interface AuthState {
+    authenticated: boolean;
+    serverUrl: string | null;
+    token?: string | null;
+    refreshToken?: string | null;
+    expiresAt?: number | null;
+    user?: {
+        id?: string;
+        email?: string;
+        name?: string;
+    } | null;
+}
+export interface AuthPollingState {
+    deviceCode: string;
+    serverUrl: string;
+    startTime: number;
+    expiresAt: number;
+    interval: number;
+}
+export declare enum AuthMessageType {
+    LOGIN_START = "LOGIN_START",
+    LOGOUT = "LOGOUT",
+    VALIDATE_AUTH = "VALIDATE_AUTH"
+}

package/shared/utils.d.ts

@@ -0,0 +1,45 @@
+import { LogSeverity } from './types';
+/**
+ * Generate a unique ID
+ */
+export declare function generateId(): string;
+/**
+ * Format timestamp to readable string
+ */
+export declare function formatTimestamp(timestamp: number): string;
+/**
+ * Format duration from milliseconds to readable string
+ */
+export declare function formatDuration(ms: number): string;
+/**
+ * Format bytes to readable size
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Get CSS selector for an element
+ */
+export declare function getSelector(element: Element): string;
+/**
+ * Safely serialize value to string
+ */
+export declare function safeStringify(value: any): string;
+/**
+ * Mask sensitive data in strings for privacy protection
+ */
+export declare function maskSensitiveData(text: string): string;
+/**
+ * Mask sensitive data in HTTP headers for privacy protection
+ */
+export declare function maskHeaders(headers: Record<string, string>): Record<string, string>;
+/**
+ * Check if a URL matches any of the excluded domain patterns
+ * Supports regex patterns for flexible matching
+ */
+export declare function isUrlExcluded(url: string, excludePatterns: string[]): boolean;
+/**
+ * Check if a log should be captured based on its severity level
+ * @param logSeverity The severity of the log
+ * @param enabledLevels Array of enabled log levels
+ * @returns true if log should be captured, false otherwise
+ */
+export declare function shouldCaptureBySeverity(logSeverity: LogSeverity | undefined, enabledLevels: LogSeverity[]): boolean;