@jhits/plugin-telemetry 0.0.4 → 0.0.6

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,37 +1,39 @@
 {
     "name": "@jhits/plugin-telemetry",
-    "version": "0.0.4",
+    "version": "0.0.6",
     "description": "System logging and telemetry utilities for the JHITS ecosystem",
     "publishConfig": {
         "access": "public"
     },
-    "main": "./src/index.ts",
-    "types": "./src/index.ts",
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "tsc"
+    },
     "exports": {
         ".": {
-            "types": "./src/index.ts",
-            "default": "./src/index.ts"
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js"
         },
         "./server": {
-            "types": "./src/server.ts",
-            "default": "./src/server.ts"
+            "types": "./dist/server.d.ts",
+            "default": "./dist/server.js"
         },
         "./api/route": {
-            "types": "./src/api/route.ts",
-            "default": "./src/api/route.ts"
+            "types": "./dist/api/route.d.ts",
+            "default": "./dist/api/route.js"
         },
         "./api/handler": {
-            "types": "./src/api/handler.ts",
-            "default": "./src/api/handler.ts"
+            "types": "./dist/api/handler.d.ts",
+            "default": "./dist/api/handler.js"
         },
         "./utils/logCleaner": {
-            "types": "./src/utils/logCleaner.ts",
-            "default": "./src/utils/logCleaner.ts"
+            "types": "./dist/utils/logCleaner.d.ts",
+            "default": "./dist/utils/logCleaner.js"
         }
     },
     "dependencies": {
-        "@jhits/plugin-core": "^0.0.1",
-        "server-only": "^0.0.1"
+        "@jhits/plugin-core": "^0.0.2"
     },
     "peerDependencies": {
         "next": ">=15.0.0",
@@ -39,18 +41,17 @@
         "react-dom": ">=18.0.0"
     },
     "devDependencies": {
-        "@types/node": "^20.19.27",
-        "@types/react": "^19",
-        "@types/react-dom": "^19",
-        "next": "16.1.1",
-        "react": "19.2.3",
-        "react-dom": "19.2.3",
-        "typescript": "^5"
+        "@types/node": "^25.2.3",
+        "@types/react": "^19.2.14",
+        "@types/react-dom": "^19.2.3",
+        "next": "16.1.6",
+        "react": "19.2.4",
+        "react-dom": "19.2.4",
+        "typescript": "^5.9.3"
     },
     "files": [
-        "src/**/*.{ts,tsx,json}",
-        "!src/**/*.md",
-        "!src/**/README.md",
+        "dist",
+        "src",
         "package.json"
     ]
 }