@jhits/plugin-telemetry 0.0.4 → 0.0.6

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';