@jhits/plugin-telemetry 0.0.5 → 0.0.7

package/dist/TelemetryProvider.d.ts

@@ -0,0 +1,8 @@
+import React, { ReactNode } from 'react';
+import { TelemetryService as ITelemetryService } from './types';
+export interface TelemetryProviderProps {
+    children: ReactNode;
+}
+export declare const TelemetryProvider: React.FC<TelemetryProviderProps>;
+export declare const useTelemetry: () => ITelemetryService;
+//# sourceMappingURL=TelemetryProvider.d.ts.map

package/dist/TelemetryProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryProvider.d.ts","sourceRoot":"","sources":["../src/TelemetryProvider.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,EAA6B,SAAS,EAAE,MAAM,OAAO,CAAC;AACpE,OAAO,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAKhE,MAAM,WAAW,sBAAsB;IACnC,QAAQ,EAAE,SAAS,CAAC;CACvB;AAED,eAAO,MAAM,iBAAiB,EAAE,KAAK,CAAC,EAAE,CAAC,sBAAsB,CAM9D,CAAC;AAEF,eAAO,MAAM,YAAY,QAAO,iBAO/B,CAAC"}

package/dist/TelemetryProvider.js

@@ -0,0 +1,20 @@
+/**
+ * Telemetry Provider
+ * React context provider for telemetry functionality
+ */
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+import { telemetryService } from './TelemetryService';
+const TelemetryContext = createContext(null);
+export const TelemetryProvider = ({ children }) => {
+    return (_jsx(TelemetryContext.Provider, { value: telemetryService, children: children }));
+};
+export const useTelemetry = () => {
+    const context = useContext(TelemetryContext);
+    if (!context) {
+        // Fallback to service directly if context is not available
+        return telemetryService;
+    }
+    return context;
+};

package/dist/TelemetryService.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Telemetry Service
+ * Core service for logging and managing telemetry data
+ * Uses backend file-based logging with buffering
+ */
+import { TelemetryEntry, TelemetryCategory, TelemetryService as ITelemetryService } from './types';
+declare class TelemetryServiceClass implements ITelemetryService {
+    private buffer;
+    private flushTimer;
+    private defaultContext;
+    private generateId;
+    /**
+     * Safe JSON stringify that handles circular references and DOM/React elements
+     * Uses WeakSet to track seen objects and returns "[Circular]" for repeated references
+     */
+    private safeStringify;
+    /**
+     * Get safe JSON serializer that handles circular references and React Fiber nodes
+     */
+    /**
+     * Send entries to backend API
+     * CRITICAL: Uses safe serializer to prevent circular JSON errors
+     */
+    private sendToBackend;
+    /**
+     * Schedule a flush of the buffer
+     */
+    private scheduleFlush;
+    /**
+     * Flush buffer to backend immediately
+     */
+    flush(useBeacon?: boolean): Promise<void>;
+    log(category: TelemetryCategory, message: string, data?: any, context?: string): void;
+    error(message: string, error: Error | unknown, data?: any, context?: string): void;
+    setContext(context: string): void;
+    exportLogs(): void;
+    clearLogs(): void;
+    getLogs(): TelemetryEntry[];
+}
+export declare const telemetryService: TelemetryServiceClass;
+export {};
+//# sourceMappingURL=TelemetryService.d.ts.map

package/dist/TelemetryService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TelemetryService.d.ts","sourceRoot":"","sources":["../src/TelemetryService.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,gBAAgB,IAAI,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAMnG,cAAM,qBAAsB,YAAW,iBAAiB;IACpD,OAAO,CAAC,MAAM,CAAwB;IACtC,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,cAAc,CAAoB;IAE1C,OAAO,CAAC,UAAU;IAIlB;;;OAGG;IACH,OAAO,CAAC,aAAa;IAkFrB;;OAEG;IACH;;;OAGG;YACW,aAAa;IAsC3B;;OAEG;IACH,OAAO,CAAC,aAAa;IAYrB;;OAEG;IACG,KAAK,CAAC,SAAS,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IActD,GAAG,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAkCrF,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IA4BlF,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IAIjC,UAAU,IAAI,IAAI;IAUlB,SAAS,IAAI,IAAI;IAajB,OAAO,IAAI,cAAc,EAAE;CAI9B;AAoDD,eAAO,MAAM,gBAAgB,uBAA8B,CAAC"}

package/dist/TelemetryService.js

@@ -0,0 +1,285 @@
+const API_ENDPOINT = '/api/dashboard/telemetry';
+const BUFFER_INTERVAL_MS = 5000; // Send buffered logs every 5 seconds
+const MAX_BUFFER_SIZE = 50; // Max entries to buffer before forcing send
+class TelemetryServiceClass {
+    constructor() {
+        this.buffer = [];
+        this.flushTimer = null;
+        this.defaultContext = 'system';
+    }
+    generateId() {
+        return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Safe JSON stringify that handles circular references and DOM/React elements
+     * Uses WeakSet to track seen objects and returns "[Circular]" for repeated references
+     */
+    safeStringify(value, space) {
+        const seen = new WeakSet();
+        const isDOMNode = (val) => {
+            return (typeof Node !== 'undefined' && val instanceof Node ||
+                typeof Element !== 'undefined' && val instanceof Element ||
+                (val && typeof val === 'object' && 'nodeType' in val && 'nodeName' in val));
+        };
+        const isReactElement = (val) => {
+            return (val &&
+                typeof val === 'object' &&
+                (val.$$typeof === Symbol.for('react.element') ||
+                    val.$$typeof === Symbol.for('react.portal') ||
+                    Object.keys(val).some(key => key.startsWith('__react') || key.startsWith('_react'))));
+        };
+        const isEvent = (val) => {
+            return (val &&
+                typeof val === 'object' &&
+                (val instanceof Event ||
+                    (typeof Event !== 'undefined' && val.constructor?.name === 'Event') ||
+                    (val.target && val.currentTarget && val.type)));
+        };
+        const replacer = (key, val) => {
+            // Skip React internal keys
+            if (key.startsWith('__react') || key.startsWith('_react')) {
+                return '[React Internal]';
+            }
+            // Handle null/undefined
+            if (val === null || val === undefined) {
+                return val;
+            }
+            // Handle DOM nodes
+            if (isDOMNode(val)) {
+                return '[DOM Node]';
+            }
+            // Handle React elements
+            if (isReactElement(val)) {
+                return '[React Element]';
+            }
+            // Handle Events
+            if (isEvent(val)) {
+                return `[Event: ${val.type || 'unknown'}]`;
+            }
+            // Handle functions
+            if (typeof val === 'function') {
+                return `[Function: ${val.name || 'anonymous'}]`;
+            }
+            // Handle circular references
+            if (typeof val === 'object') {
+                if (seen.has(val)) {
+                    return '[Circular]';
+                }
+                seen.add(val);
+            }
+            return val;
+        };
+        try {
+            return JSON.stringify(value, replacer, space);
+        }
+        catch (error) {
+            // Fallback if stringify still fails
+            return JSON.stringify({
+                error: 'Failed to stringify',
+                message: error instanceof Error ? error.message : String(error),
+                type: typeof value,
+            }, null, space);
+        }
+    }
+    /**
+     * Get safe JSON serializer that handles circular references and React Fiber nodes
+     */
+    /**
+     * Send entries to backend API
+     * CRITICAL: Uses safe serializer to prevent circular JSON errors
+     */
+    async sendToBackend(entries, useBeacon = false) {
+        if (entries.length === 0)
+            return;
+        try {
+            // SAFE SERIALIZER to prevent Circular structure errors
+            const getCircularReplacer = () => {
+                const seen = new WeakSet();
+                return (key, value) => {
+                    if (typeof value === "object" && value !== null) {
+                        if (seen.has(value))
+                            return "[Circular]";
+                        seen.add(value);
+                        // Strip out DOM elements and React internals
+                        if (value instanceof Node)
+                            return `[DOM: ${value.nodeName}]`;
+                        if (key.startsWith('__react'))
+                            return "[ReactInternal]";
+                    }
+                    return value;
+                };
+            };
+            const data = JSON.stringify(entries, getCircularReplacer());
+            if (navigator.sendBeacon && useBeacon) {
+                const blob = new Blob([data], { type: 'application/json' });
+                if (navigator.sendBeacon(API_ENDPOINT, blob))
+                    return;
+            }
+            const response = await fetch(API_ENDPOINT, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: data,
+            });
+            if (!response.ok)
+                throw new Error(`Status ${response.status}`);
+        }
+        catch (error) {
+            console.error('[TelemetryService] Serialization or Network failure:', error);
+        }
+    }
+    /**
+     * Schedule a flush of the buffer
+     */
+    scheduleFlush() {
+        // Clear existing timer
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+        }
+        // Schedule new flush
+        this.flushTimer = setTimeout(() => {
+            this.flush();
+        }, BUFFER_INTERVAL_MS);
+    }
+    /**
+     * Flush buffer to backend immediately
+     */
+    async flush(useBeacon = false) {
+        if (this.buffer.length === 0)
+            return;
+        const entriesToSend = [...this.buffer];
+        this.buffer = [];
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        await this.sendToBackend(entriesToSend, useBeacon);
+    }
+    log(category, message, data, context) {
+        const entry = {
+            id: this.generateId(),
+            timestamp: Date.now(),
+            category,
+            message,
+            data: data || {},
+            context: context || this.defaultContext,
+        };
+        // Add to buffer
+        this.buffer.push(entry);
+        // Also log to console for immediate visibility (less intrusive, emoji-coded breadcrumbs)
+        // Only log in development or if explicitly enabled
+        if (process.env.NODE_ENV === 'development' || process.env.TELEMETRY_VERBOSE === 'true') {
+            const emoji = category === 'DRAG_DROP' ? '📦' : category === 'STATE' ? '📊' : category === 'ERROR' ? '❌' : '🎨';
+            // Use safeStringify for console logs too to prevent circular reference errors
+            const safeData = data ? this.safeStringify(data) : '';
+            console.log(`${emoji} [${entry.context}] ${message}`, safeData || '');
+        }
+        // Send immediately if ERROR, otherwise schedule flush
+        if (category === 'ERROR') {
+            this.flush();
+        }
+        else if (this.buffer.length >= MAX_BUFFER_SIZE) {
+            // Force flush if buffer is getting large
+            this.flush();
+        }
+        else {
+            // Schedule regular flush
+            this.scheduleFlush();
+        }
+    }
+    error(message, error, data, context) {
+        const errorObj = error instanceof Error ? error : new Error(String(error));
+        const entry = {
+            id: this.generateId(),
+            timestamp: Date.now(),
+            category: 'ERROR',
+            message,
+            data: {
+                ...data,
+                errorMessage: errorObj.message,
+                errorName: errorObj.name,
+            },
+            stack: errorObj.stack,
+            context: context || this.defaultContext,
+        };
+        // Add to buffer
+        this.buffer.push(entry);
+        // Also log to console for immediate visibility (errors always shown, but with safe stringify)
+        // Use safeStringify to prevent circular reference errors in console
+        const safeData = data ? this.safeStringify(data) : '';
+        console.error(`❌ [${entry.context}] ${message}`, error instanceof Error ? error.message : String(error), safeData || '');
+        // Errors are sent immediately
+        this.flush();
+    }
+    setContext(context) {
+        this.defaultContext = context;
+    }
+    exportLogs() {
+        // Flush any pending logs first
+        this.flush().then(() => {
+            // Inform user that logs are on the server
+            alert('Telemetry logs are stored on the server at: logs/editor-debug.log\n\nCheck the server logs directory for the file.');
+        }).catch(() => {
+            alert('Telemetry logs are stored on the server. Check logs/editor-debug.log on the server.');
+        });
+    }
+    clearLogs() {
+        // Clear the buffer (logs are already on server, can't clear server logs from client)
+        this.buffer = [];
+        if (this.flushTimer) {
+            clearTimeout(this.flushTimer);
+            this.flushTimer = null;
+        }
+        // Less intrusive console log
+        if (process.env.NODE_ENV === 'development' || process.env.TELEMETRY_VERBOSE === 'true') {
+            console.log('🧹 Telemetry buffer cleared');
+        }
+    }
+    getLogs() {
+        // Return current buffer (server logs are not accessible from client)
+        return [...this.buffer];
+    }
+}
+// Initialize global error handlers
+const initializeGlobalErrorHandlers = (service) => {
+    // Capture window.onerror
+    const originalOnError = window.onerror;
+    window.onerror = (message, source, lineno, colno, error) => {
+        service.error('Global Error Handler', error || new Error(String(message)), {
+            message: String(message),
+            source: String(source),
+            lineno,
+            colno,
+        });
+        if (originalOnError) {
+            return originalOnError(message, source, lineno, colno, error);
+        }
+        return false;
+    };
+    // Capture unhandled promise rejections
+    window.addEventListener('unhandledrejection', (event) => {
+        service.error('Unhandled Promise Rejection', event.reason, {
+            // Don't include the promise object itself (can cause circular references)
+            reason: event.reason instanceof Error ? event.reason.message : String(event.reason),
+        });
+    });
+};
+// Initialize unload handler for flushing logs
+const initializeUnloadHandler = (service) => {
+    // Flush logs on page unload using sendBeacon
+    window.addEventListener('beforeunload', () => {
+        service.flush(true); // Use sendBeacon for unload
+    });
+    // Also handle visibility change (tab switch, minimize, etc.)
+    document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'hidden') {
+            service.flush(true); // Use sendBeacon when tab becomes hidden
+        }
+    });
+};
+// Create singleton instance
+export const telemetryService = new TelemetryServiceClass();
+// Initialize global error handlers and unload handler
+if (typeof window !== 'undefined') {
+    initializeGlobalErrorHandlers(telemetryService);
+    initializeUnloadHandler(telemetryService);
+}

package/dist/api/handler.d.ts

@@ -0,0 +1,20 @@
+import 'server-only';
+/**
+ * Telemetry API Handler
+ * Plugin-mounted API handler for telemetry logging
+ * Compatible with Next.js API routes and Express
+ *
+ * IMPORTANT: This file should ONLY be imported in server-side API routes.
+ * Do NOT import this in client-side code.
+ */
+import { NextRequest, NextResponse } from 'next/server';
+/**
+ * Next.js API Route Handler
+ */
+export declare function POST(request: NextRequest): Promise<NextResponse>;
+/**
+ * Express-compatible handler
+ * For use with Express.js or other Node.js frameworks
+ */
+export declare function telemetryHandler(req: any, res: any): void;
+//# sourceMappingURL=handler.d.ts.map

package/dist/api/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../src/api/handler.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAC;AAErB;;;;;;;GAOG;AACH,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA6IxD;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,YAAY,CAAC,CAgEtE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,GAAG,IAAI,CAmDzD"}

package/dist/api/handler.js

@@ -0,0 +1,229 @@
+import 'server-only';
+/**
+ * Telemetry API Handler
+ * Plugin-mounted API handler for telemetry logging
+ * Compatible with Next.js API routes and Express
+ *
+ * IMPORTANT: This file should ONLY be imported in server-side API routes.
+ * Do NOT import this in client-side code.
+ */
+import { NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+const LOG_DIR = path.join(process.cwd(), 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'jhits-system.log');
+const OLD_LOG_FILE = path.join(LOG_DIR, 'jhits-system.old.log');
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
+const MAX_BATCH_SIZE = 100; // Maximum entries per request
+const MAX_ENTRY_SIZE = 100 * 1024; // 100KB per entry
+/**
+ * Ensure logs directory exists
+ */
+async function ensureLogDir() {
+    try {
+        await fs.access(LOG_DIR);
+    }
+    catch {
+        await fs.mkdir(LOG_DIR, { recursive: true });
+    }
+}
+/**
+ * Check log file size and rotate if necessary
+ */
+async function rotateLogIfNeeded() {
+    try {
+        const stats = await fs.stat(LOG_FILE);
+        if (stats.size > MAX_LOG_SIZE) {
+            // Rename current log to old log
+            try {
+                await fs.rename(LOG_FILE, OLD_LOG_FILE);
+            }
+            catch (error) {
+                // If old log exists, remove it first
+                if (error.code === 'EEXIST' || error.code === 'ENOENT') {
+                    try {
+                        await fs.unlink(OLD_LOG_FILE);
+                        await fs.rename(LOG_FILE, OLD_LOG_FILE);
+                    }
+                    catch {
+                        // If still fails, just overwrite
+                        await fs.copyFile(LOG_FILE, OLD_LOG_FILE);
+                        await fs.unlink(LOG_FILE);
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If file doesn't exist, that's fine - we'll create it
+        if (error.code !== 'ENOENT') {
+            console.error('[Telemetry Handler] Error checking log size:', error);
+        }
+    }
+}
+/**
+ * Format log entry as single-line JSON
+ */
+function formatLogEntry(entry) {
+    const timestamp = new Date(entry.timestamp).toISOString();
+    const context = entry.context || 'unknown';
+    const userId = entry.userId || 'anonymous';
+    const sessionId = entry.sessionId || 'unknown';
+    // Sanitize data to prevent log injection
+    const sanitizedData = typeof entry.data === 'object'
+        ? JSON.stringify(entry.data).replace(/\n/g, '\\n').replace(/\r/g, '\\r')
+        : String(entry.data);
+    const stackStr = entry.stack ? ` "stack":"${entry.stack.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"` : '';
+    return `[${timestamp}] [${context}] [${userId}] [${sessionId}] [${entry.category}] ${entry.message} ${sanitizedData}${stackStr}\n`;
+}
+/**
+ * Validate and sanitize telemetry entry
+ */
+function validateEntry(entry) {
+    // Basic validation
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    // Check required fields
+    if (!entry.id || !entry.timestamp || !entry.category || !entry.message) {
+        return null;
+    }
+    // Size check to prevent log injection attacks
+    const entrySize = JSON.stringify(entry).length;
+    if (entrySize > MAX_ENTRY_SIZE) {
+        console.warn('[Telemetry Handler] Entry too large, skipping:', entry.id);
+        return null;
+    }
+    // Sanitize string fields
+    return {
+        id: String(entry.id).substring(0, 100),
+        timestamp: Number(entry.timestamp),
+        category: String(entry.category).substring(0, 50),
+        message: String(entry.message).substring(0, 500),
+        data: entry.data || {},
+        stack: entry.stack ? String(entry.stack).substring(0, 5000) : undefined,
+        context: entry.context ? String(entry.context).substring(0, 100) : undefined,
+        userId: entry.userId ? String(entry.userId).substring(0, 100) : undefined,
+        sessionId: entry.sessionId ? String(entry.sessionId).substring(0, 100) : undefined,
+    };
+}
+/**
+ * Extract user/session info from request headers or cookies
+ */
+function extractContext(request) {
+    // Try to get user ID from headers (custom header)
+    const userId = request.headers.get('x-user-id') ||
+        request.headers.get('x-userid') ||
+        undefined;
+    // Try to get session ID from headers or cookies
+    const sessionId = request.headers.get('x-session-id') ||
+        request.headers.get('x-sessionid') ||
+        request.cookies.get('sessionId')?.value ||
+        request.cookies.get('session')?.value ||
+        undefined;
+    return { userId, sessionId };
+}
+/**
+ * Next.js API Route Handler
+ */
+export async function POST(request) {
+    try {
+        // Ensure log directory exists
+        await ensureLogDir();
+        // Rotate log if needed
+        await rotateLogIfNeeded();
+        // Extract context from request
+        const { userId, sessionId } = extractContext(request);
+        // Parse request body
+        const body = await request.json();
+        // Handle single entry or batch of entries
+        const entries = Array.isArray(body) ? body : [body];
+        // Rate limiting: Check batch size
+        if (entries.length > MAX_BATCH_SIZE) {
+            return NextResponse.json({ success: false, error: `Batch size exceeds maximum of ${MAX_BATCH_SIZE}` }, { status: 400 });
+        }
+        // Validate and sanitize entries
+        const validEntries = [];
+        for (const entry of entries) {
+            const validated = validateEntry(entry);
+            if (validated) {
+                // Add context from request if not present in entry
+                if (!validated.userId && userId) {
+                    validated.userId = userId;
+                }
+                if (!validated.sessionId && sessionId) {
+                    validated.sessionId = sessionId;
+                }
+                validEntries.push(validated);
+            }
+        }
+        if (validEntries.length === 0) {
+            return NextResponse.json({ success: false, error: 'No valid entries to log' }, { status: 400 });
+        }
+        // Format and append each entry
+        const logLines = validEntries.map(formatLogEntry).join('');
+        await fs.appendFile(LOG_FILE, logLines, 'utf8');
+        return NextResponse.json({
+            success: true,
+            logged: validEntries.length,
+            rejected: entries.length - validEntries.length
+        });
+    }
+    catch (error) {
+        console.error('[Telemetry Handler] Error writing log:', error);
+        return NextResponse.json({ success: false, error: 'Failed to write log' }, { status: 500 });
+    }
+}
+/**
+ * Express-compatible handler
+ * For use with Express.js or other Node.js frameworks
+ */
+export function telemetryHandler(req, res) {
+    // This is a simplified version for Express
+    // In a real Express setup, you'd need to adapt the NextRequest/NextResponse types
+    const handler = async () => {
+        try {
+            await ensureLogDir();
+            await rotateLogIfNeeded();
+            const body = req.body;
+            const entries = Array.isArray(body) ? body : [body];
+            if (entries.length > MAX_BATCH_SIZE) {
+                return res.status(400).json({
+                    success: false,
+                    error: `Batch size exceeds maximum of ${MAX_BATCH_SIZE}`
+                });
+            }
+            const validEntries = [];
+            for (const entry of entries) {
+                const validated = validateEntry(entry);
+                if (validated) {
+                    // Extract from Express request
+                    validated.userId = validated.userId || req.headers['x-user-id'] || req.user?.id;
+                    validated.sessionId = validated.sessionId || req.headers['x-session-id'] || req.session?.id;
+                    validEntries.push(validated);
+                }
+            }
+            if (validEntries.length === 0) {
+                return res.status(400).json({
+                    success: false,
+                    error: 'No valid entries to log'
+                });
+            }
+            const logLines = validEntries.map(formatLogEntry).join('');
+            await fs.appendFile(LOG_FILE, logLines, 'utf8');
+            res.json({
+                success: true,
+                logged: validEntries.length,
+                rejected: entries.length - validEntries.length
+            });
+        }
+        catch (error) {
+            console.error('[Telemetry Handler] Error writing log:', error);
+            res.status(500).json({ success: false, error: 'Failed to write log' });
+        }
+    };
+    handler();
+}

package/dist/api/route.d.ts

@@ -0,0 +1,9 @@
+import 'server-only';
+/**
+ * Telemetry API Route Handler
+ * Server-only wrapper for the telemetry handler
+ * This file should ONLY be used in Next.js API routes
+ */
+import { POST as handlerPOST } from './handler';
+export { handlerPOST as POST };
+//# sourceMappingURL=route.d.ts.map

package/dist/api/route.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.d.ts","sourceRoot":"","sources":["../../src/api/route.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAC;AAErB;;;;GAIG;AACH,OAAO,EAAE,IAAI,IAAI,WAAW,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAAE,WAAW,IAAI,IAAI,EAAE,CAAC"}

package/dist/api/route.js

@@ -0,0 +1,8 @@
+import 'server-only';
+/**
+ * Telemetry API Route Handler
+ * Server-only wrapper for the telemetry handler
+ * This file should ONLY be used in Next.js API routes
+ */
+import { POST as handlerPOST } from './handler';
+export { handlerPOST as POST };

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Plugin Telemetry
+ * Standalone telemetry package for JHITS v2
+ *
+ * NOTE: API handler is NOT exported here to prevent client-side bundling.
+ * Import the handler directly from '@jhits/plugin-telemetry/api/handler' in server-side API routes only.
+ */
+export { TelemetryProvider, useTelemetry } from './TelemetryProvider';
+export { telemetryService } from './TelemetryService';
+export type { TelemetryEntry, TelemetryCategory, TelemetryService } from './types';
+export { summarizeBlock, summarizeBlocks, createBlockActionPayload } from './utils/logCleaner';
+export type { BlockSummary, MoveBlockData, DeleteBlockData, InsertBlockData } from './utils/logCleaner';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,YAAY,EAAE,cAAc,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,eAAe,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAC;AAC/F,YAAY,EAAE,YAAY,EAAE,aAAa,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/index.js

@@ -0,0 +1,10 @@
+/**
+ * Plugin Telemetry
+ * Standalone telemetry package for JHITS v2
+ *
+ * NOTE: API handler is NOT exported here to prevent client-side bundling.
+ * Import the handler directly from '@jhits/plugin-telemetry/api/handler' in server-side API routes only.
+ */
+export { TelemetryProvider, useTelemetry } from './TelemetryProvider';
+export { telemetryService } from './TelemetryService';
+export { summarizeBlock, summarizeBlocks, createBlockActionPayload } from './utils/logCleaner';

package/dist/server.d.ts

@@ -0,0 +1,55 @@
+import 'server-only';
+/**
+ * Server-only exports for @jhits/plugin-telemetry
+ * These exports should only be used in server-side code (API routes, server components)
+ */
+interface PluginRegistration {
+    name: string;
+    version: string;
+    description?: string;
+    routes: Array<{
+        path: string;
+        component: string;
+    }>;
+    apiHandlers: Array<{
+        method: string;
+        path: string;
+        handler: string;
+    }>;
+    cssFiles: string[];
+    setup?: () => Promise<void>;
+    dependencies?: string[];
+    config?: Record<string, any>;
+}
+import { NextRequest, NextResponse } from 'next/server';
+/**
+ * Main API handler for telemetry plugin
+ */
+export declare function handleApi(req: NextRequest, path: string[], config: any): Promise<NextResponse>;
+/**
+ * Plugin registration for auto-configuration
+ */
+export declare function registerPlugin(): Promise<PluginRegistration>;
+/**
+ * API handler for retrieving logs
+ */
+export declare function getLogsHandler(req: NextRequest, path: string[], config: any): Promise<NextResponse>;
+/**
+ * Telemetry Handler
+ * Server-only function for processing telemetry data
+ *
+ * @param data - Telemetry entry or array of entries
+ * @param context - Optional context with userId and sessionId
+ * @returns Result object with success status and logging information
+ */
+export declare function telemetryHandler(data: any, context?: {
+    userId?: string;
+    sessionId?: string;
+}): Promise<{
+    success: boolean;
+    logged?: number;
+    rejected?: number;
+    error?: string;
+}>;
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,CAAC;AAErB;;;GAGG;AAGH,UAAU,kBAAkB;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACnD,WAAW,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACtE,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC9B;AAED,OAAO,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAoExD;;GAEG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,GAAG,GACV,OAAO,CAAC,YAAY,CAAC,CA8BvB;AAED;;GAEG;AACH,wBAAsB,cAAc,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAyClE;AAED;;GAEG;AACH,wBAAsB,cAAc,CAClC,GAAG,EAAE,WAAW,EAChB,IAAI,EAAE,MAAM,EAAE,EACd,MAAM,EAAE,GAAG,GACV,OAAO,CAAC,YAAY,CAAC,CAkCvB;AA8FD;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,IAAI,EAAE,GAAG,EACT,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,GAClD,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA2DnF"}

package/dist/server.js

@@ -0,0 +1,313 @@
+import 'server-only';
+import { NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+const LOG_DIR = path.join(process.cwd(), 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'jhits-system.log');
+const OLD_LOG_FILE = path.join(LOG_DIR, 'jhits-system.old.log');
+const MAX_LOG_SIZE = 10 * 1024 * 1024; // 10MB
+const MAX_BATCH_SIZE = 100; // Maximum entries per request
+const MAX_ENTRY_SIZE = 100 * 1024; // 100KB per entry
+/**
+ * Ensure logs directory exists
+ */
+async function ensureLogDir() {
+    try {
+        await fs.access(LOG_DIR);
+    }
+    catch {
+        await fs.mkdir(LOG_DIR, { recursive: true });
+    }
+}
+/**
+ * Check log file size and rotate if necessary
+ */
+async function rotateLogIfNeeded() {
+    try {
+        const stats = await fs.stat(LOG_FILE);
+        if (stats.size > MAX_LOG_SIZE) {
+            // Rename current log to old log
+            try {
+                await fs.rename(LOG_FILE, OLD_LOG_FILE);
+            }
+            catch (error) {
+                // If old log exists, remove it first
+                if (error.code === 'EEXIST' || error.code === 'ENOENT') {
+                    try {
+                        await fs.unlink(OLD_LOG_FILE);
+                        await fs.rename(LOG_FILE, OLD_LOG_FILE);
+                    }
+                    catch {
+                        // If still fails, just overwrite
+                        await fs.copyFile(LOG_FILE, OLD_LOG_FILE);
+                        await fs.unlink(LOG_FILE);
+                    }
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+    }
+    catch (error) {
+        // If file doesn't exist, that's fine - we'll create it
+        if (error.code !== 'ENOENT') {
+            console.error('[Telemetry Handler] Error checking log size:', error);
+        }
+    }
+}
+/**
+ * Main API handler for telemetry plugin
+ */
+export async function handleApi(req, path, config) {
+    try {
+        const { searchParams } = new URL(req.url);
+        const action = path[0] || 'log';
+        switch (action) {
+            case 'log':
+                const data = await req.json();
+                const result = await telemetryHandler(data, {
+                    userId: req.headers.get('x-user-id') || undefined,
+                    sessionId: req.headers.get('x-session-id') || undefined
+                });
+                return NextResponse.json(result);
+            case 'logs':
+                return await getLogsHandler(req, path, config);
+            default:
+                return NextResponse.json({
+                    success: false,
+                    error: 'Unknown telemetry action'
+                }, { status: 404 });
+        }
+    }
+    catch (error) {
+        console.error('[Telemetry API] Error:', error);
+        return NextResponse.json({
+            success: false,
+            error: 'Internal server error'
+        }, { status: 500 });
+    }
+}
+/**
+ * Plugin registration for auto-configuration
+ */
+export async function registerPlugin() {
+    return {
+        name: 'telemetry',
+        version: '0.0.1',
+        description: 'System telemetry and logging plugin',
+        routes: [
+            {
+                path: '/dashboard/telemetry',
+                component: 'TelemetryDashboard'
+            }
+        ],
+        apiHandlers: [
+            {
+                method: 'POST',
+                path: '/log',
+                handler: 'telemetryHandler'
+            },
+            {
+                method: 'GET',
+                path: '/logs',
+                handler: 'getLogsHandler'
+            }
+        ],
+        cssFiles: ['telemetry-styles.css'],
+        setup: async () => {
+            // Create logs directory
+            const { mkdir } = await import('fs/promises');
+            const { join } = await import('path');
+            try {
+                await mkdir(join(process.cwd(), 'logs'), { recursive: true });
+            }
+            catch (error) {
+                // Directory might already exist
+            }
+        },
+        dependencies: [],
+        config: {
+            maxLogSize: 10 * 1024 * 1024, // 10MB
+            maxBatchSize: 100,
+            maxEntrySize: 100 * 1024 // 100KB
+        }
+    };
+}
+/**
+ * API handler for retrieving logs
+ */
+export async function getLogsHandler(req, path, config) {
+    try {
+        const fs = await import('fs/promises');
+        const path = await import('path');
+        const LOG_FILE = path.join(process.cwd(), 'logs', 'jhits-system.log');
+        const { searchParams } = new URL(req.url);
+        const lines = parseInt(searchParams.get('lines') || '100');
+        const category = searchParams.get('category');
+        // Read log file
+        const logContent = await fs.readFile(LOG_FILE, 'utf8');
+        const logLines = logContent.split('\n').filter(line => line.trim());
+        // Filter by category if specified
+        const filteredLines = category
+            ? logLines.filter(line => line.includes(`[${category}]`))
+            : logLines;
+        // Get last N lines
+        const recentLines = filteredLines.slice(-lines);
+        return NextResponse.json({
+            success: true,
+            logs: recentLines,
+            total: filteredLines.length
+        });
+    }
+    catch (error) {
+        return NextResponse.json({
+            success: false,
+            error: 'Failed to read logs',
+            logs: []
+        }, { status: 500 });
+    }
+}
+/**
+ * Format log entry as single-line JSON (or pretty-printed in debug mode)
+ * CRITICAL: Single-line format for easier grep/tailing, but pretty-printed if debug flag is on
+ */
+function formatLogEntry(entry, debug = false) {
+    const timestamp = new Date(entry.timestamp).toISOString();
+    const context = entry.context || 'unknown';
+    const userId = entry.userId || 'anonymous';
+    const sessionId = entry.sessionId || 'unknown';
+    // Check for debug mode via environment variable
+    const isDebugMode = debug || process.env.TELEMETRY_DEBUG === 'true';
+    if (isDebugMode) {
+        // Pretty-printed format for debugging
+        const logObject = {
+            timestamp,
+            context,
+            userId,
+            sessionId,
+            category: entry.category,
+            message: entry.message,
+            data: entry.data,
+            ...(entry.stack && { stack: entry.stack })
+        };
+        return JSON.stringify(logObject, null, 2) + '\n';
+    }
+    else {
+        // Single-line JSON format for production (easier grep/tailing)
+        const sanitizedData = typeof entry.data === 'object'
+            ? JSON.stringify(entry.data).replace(/\n/g, '\\n').replace(/\r/g, '\\r')
+            : String(entry.data);
+        const stackStr = entry.stack ? ` "stack":"${entry.stack.replace(/"/g, '\\"').replace(/\n/g, '\\n')}"` : '';
+        return `[${timestamp}] [${context}] [${userId}] [${sessionId}] [${entry.category}] ${entry.message} ${sanitizedData}${stackStr}\n`;
+    }
+}
+/**
+ * Validate and sanitize telemetry entry
+ */
+function validateEntry(entry) {
+    // Basic validation
+    if (!entry || typeof entry !== 'object') {
+        return null;
+    }
+    // Check required fields
+    if (!entry.id || !entry.timestamp || !entry.category || !entry.message) {
+        return null;
+    }
+    // Size check to prevent log injection attacks
+    const entrySize = JSON.stringify(entry).length;
+    if (entrySize > MAX_ENTRY_SIZE) {
+        console.warn('[Telemetry Handler] Entry too large, skipping:', entry.id);
+        return null;
+    }
+    // Sanitize string fields
+    return {
+        id: String(entry.id).substring(0, 100),
+        timestamp: Number(entry.timestamp),
+        category: String(entry.category).substring(0, 50),
+        message: String(entry.message).substring(0, 500),
+        data: entry.data || {},
+        stack: entry.stack ? String(entry.stack).substring(0, 5000) : undefined,
+        context: entry.context ? String(entry.context).substring(0, 100) : undefined,
+        userId: entry.userId ? String(entry.userId).substring(0, 100) : undefined,
+        sessionId: entry.sessionId ? String(entry.sessionId).substring(0, 100) : undefined,
+    };
+}
+/**
+ * Extract user/session info from request headers or cookies
+ */
+function extractContext(request) {
+    // Try to get user ID from headers (custom header)
+    const userId = request.headers.get('x-user-id') ||
+        request.headers.get('x-userid') ||
+        undefined;
+    // Try to get session ID from headers or cookies
+    const sessionId = request.headers.get('x-session-id') ||
+        request.headers.get('x-sessionid') ||
+        request.cookies.get('sessionId')?.value ||
+        request.cookies.get('session')?.value ||
+        undefined;
+    return { userId, sessionId };
+}
+/**
+ * Telemetry Handler
+ * Server-only function for processing telemetry data
+ *
+ * @param data - Telemetry entry or array of entries
+ * @param context - Optional context with userId and sessionId
+ * @returns Result object with success status and logging information
+ */
+export async function telemetryHandler(data, context) {
+    try {
+        // Ensure log directory exists
+        await ensureLogDir();
+        // Rotate log if needed
+        await rotateLogIfNeeded();
+        // Handle single entry or batch of entries
+        const entries = Array.isArray(data) ? data : [data];
+        // Rate limiting: Check batch size
+        if (entries.length > MAX_BATCH_SIZE) {
+            return {
+                success: false,
+                error: `Batch size exceeds maximum of ${MAX_BATCH_SIZE}`
+            };
+        }
+        // Validate and sanitize entries
+        const validEntries = [];
+        for (const entry of entries) {
+            const validated = validateEntry(entry);
+            if (validated) {
+                // Add context if provided
+                if (context?.userId && !validated.userId) {
+                    validated.userId = context.userId;
+                }
+                if (context?.sessionId && !validated.sessionId) {
+                    validated.sessionId = context.sessionId;
+                }
+                validEntries.push(validated);
+            }
+        }
+        if (validEntries.length === 0) {
+            return {
+                success: false,
+                error: 'No valid entries to log'
+            };
+        }
+        // Format and append each entry (check for debug mode)
+        const debugMode = process.env.TELEMETRY_DEBUG === 'true';
+        const logLines = validEntries.map(entry => formatLogEntry(entry, debugMode)).join('');
+        await fs.appendFile(LOG_FILE, logLines, 'utf8');
+        return {
+            success: true,
+            logged: validEntries.length,
+            rejected: entries.length - validEntries.length
+        };
+    }
+    catch (error) {
+        console.error('[Telemetry Handler] Error writing log:', error);
+        return {
+            success: false,
+            error: 'Failed to write log',
+        };
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Telemetry Types
+ * Type definitions for the telemetry system
+ */
+export type TelemetryCategory = 'DRAG_DROP' | 'STATE' | 'ERROR' | 'UI';
+export interface TelemetryEntry {
+    id: string;
+    timestamp: number;
+    category: TelemetryCategory;
+    message: string;
+    data: any;
+    stack?: string;
+    context?: string;
+    userId?: string;
+    sessionId?: string;
+}
+export interface TelemetryService {
+    log: (category: TelemetryCategory, message: string, data?: any, context?: string) => void;
+    error: (message: string, error: Error | unknown, data?: any, context?: string) => void;
+    exportLogs: () => void;
+    clearLogs: () => void;
+    getLogs: () => TelemetryEntry[];
+    flush: () => Promise<void>;
+    setContext: (context: string) => void;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC;AAEvE,MAAM,WAAW,cAAc;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,iBAAiB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,GAAG,CAAC;IACV,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC7B,GAAG,EAAE,CAAC,QAAQ,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IAC1F,KAAK,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,OAAO,EAAE,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACvF,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,OAAO,EAAE,MAAM,cAAc,EAAE,CAAC;IAChC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B,UAAU,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAC;CACzC"}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Telemetry Types
+ * Type definitions for the telemetry system
+ */
+export {};

package/dist/utils/logCleaner.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Log Cleaner Utilities
+ * Optimizes telemetry payloads by summarizing large data structures
+ */
+interface BlockLike {
+    id: string | number;
+    type?: string;
+    nestedBlocks?: BlockLike[];
+}
+/**
+ * Summarized block representation for telemetry
+ */
+export interface BlockSummary {
+    id: string;
+    type: string;
+    childCount: number;
+}
+/**
+ * Summarize a single block to reduce log payload size
+ * Only includes essential information: id, type, and child count
+ */
+export declare function summarizeBlock(block: BlockLike | {
+    id: string;
+    type: string;
+    nestedBlocks?: any[];
+}): BlockSummary;
+/**
+ * Summarize an array of blocks to reduce log payload size
+ * Recursively summarizes nested blocks up to a maximum depth
+ */
+export declare function summarizeBlocks(blocks: BlockLike[] | undefined, maxDepth?: number): BlockSummary[];
+/**
+ * Extract action-specific data for telemetry
+ */
+export interface MoveBlockData {
+    blockId: string;
+    fromParent: string | null;
+    toParent: string | null;
+    fromIndex?: number;
+    toIndex: number;
+}
+export interface DeleteBlockData {
+    blockId: string;
+    blockType: string;
+    parentId: string | null;
+}
+export interface InsertBlockData {
+    newBlockType: string;
+    parentId: string | null;
+    index: number;
+    newBlockId?: string;
+}
+/**
+ * Create optimized telemetry payload for block operations
+ * Removes full block arrays and only includes essential action data
+ */
+export declare function createBlockActionPayload(actionType: 'MOVE_BLOCK' | 'DELETE_BLOCK' | 'INSERT_BLOCK', data: MoveBlockData | DeleteBlockData | InsertBlockData, options?: {
+    includeBlocks?: boolean;
+    affectedBlockId?: string;
+}): Record<string, any>;
+export {};
+//# sourceMappingURL=logCleaner.d.ts.map

package/dist/utils/logCleaner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logCleaner.d.ts","sourceRoot":"","sources":["../../src/utils/logCleaner.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,UAAU,SAAS;IACf,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,SAAS,EAAE,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,GAAG,EAAE,CAAA;CAAE,GAAG,YAAY,CAMlH;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC3B,MAAM,EAAE,SAAS,EAAE,GAAG,SAAS,EAC/B,QAAQ,GAAE,MAAU,GACrB,YAAY,EAAE,CAoBhB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACpC,UAAU,EAAE,YAAY,GAAG,cAAc,GAAG,cAAc,EAC1D,IAAI,EAAE,aAAa,GAAG,eAAe,GAAG,eAAe,EACvD,OAAO,CAAC,EAAE;IACN,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,GACF,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAYrB"}

package/dist/utils/logCleaner.js

@@ -0,0 +1,52 @@
+/**
+ * Log Cleaner Utilities
+ * Optimizes telemetry payloads by summarizing large data structures
+ */
+/**
+ * Summarize a single block to reduce log payload size
+ * Only includes essential information: id, type, and child count
+ */
+export function summarizeBlock(block) {
+    return {
+        id: String(block.id),
+        type: String(block.type || 'unknown'),
+        childCount: Array.isArray(block.nestedBlocks) ? block.nestedBlocks.length : 0
+    };
+}
+/**
+ * Summarize an array of blocks to reduce log payload size
+ * Recursively summarizes nested blocks up to a maximum depth
+ */
+export function summarizeBlocks(blocks, maxDepth = 2) {
+    if (!Array.isArray(blocks) || blocks.length === 0) {
+        return [];
+    }
+    return blocks.map(block => {
+        const summary = {
+            id: String(block.id),
+            type: String(block.type || 'unknown'),
+            childCount: Array.isArray(block.nestedBlocks) ? block.nestedBlocks.length : 0
+        };
+        // Optionally include nested summaries if depth allows (for debugging)
+        if (maxDepth > 0 && block.nestedBlocks && block.nestedBlocks.length > 0) {
+            // Only include nested summaries in debug mode
+            // For production, just the childCount is sufficient
+        }
+        return summary;
+    });
+}
+/**
+ * Create optimized telemetry payload for block operations
+ * Removes full block arrays and only includes essential action data
+ */
+export function createBlockActionPayload(actionType, data, options) {
+    const payload = {
+        actionType,
+        ...data
+    };
+    // Only include full blocks for critical errors
+    if (options?.includeBlocks && options.affectedBlockId) {
+        payload.affectedBlockId = options.affectedBlockId;
+    }
+    return payload;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jhits/plugin-telemetry",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "System logging and telemetry utilities for the JHITS ecosystem",
   "publishConfig": {
     "access": "public"
@@ -30,7 +30,7 @@
     }
   },
   "dependencies": {
-    "@jhits/plugin-core": "^0.0.2"
+    "@jhits/plugin-core": "0.0.2"
   },
   "peerDependencies": {
     "next": ">=15.0.0",