npm - dashcam - Versions diffs - 1.4.13-beta.2 → 1.4.13-beta.3 - Mend

dashcam 1.4.13-beta.2 → 1.4.13-beta.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/bin/dashcam.js +0 -2
package/lib/recorder.js +2 -2
package/package.json +1 -1
package/691cc08dc2fc02f59ae66f08 (1).mp4 +0 -0
package/LINUX_PERF_FIX.md +0 -184
package/LOG_TRACKING_GUIDE.md +0 -225
package/NPM_PUBLISH_FIX.md +0 -104
package/PERFORMANCE_TRACKING.md +0 -139
package/SINGLE_FRAME_VIDEO_FIX.md +0 -129
package/examples/execute-script.js +0 -150
package/examples/simple-test.js +0 -37
package/recording.log +0 -814
package/sea-bundle.mjs +0 -34595
package/test-page.html +0 -15
package/test-perf-linux.js +0 -208
package/test-perf-tracker.js +0 -52
package/test-performance-tracking.js +0 -108
package/test-short-recording.js +0 -287
package/test-top-processes.js +0 -23
package/test.log +0 -1
package/test_run.log +0 -48

package/test-page.html DELETED Viewed

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Test Page for Extension</title>
-</head>
-<body>
-    <h1>Simple Test Page</h1>
-    <p>This is a test page for the Chrome extension script execution.</p>
-    <p id="result">Waiting for script execution...</p>
-    <script>
-        console.log('Test page loaded, title:', document.title);
-    </script>
-</body>
-</html>

package/test-perf-linux.js DELETED Viewed

@@ -1,208 +0,0 @@
-#!/usr/bin/env node
-/**
- * Linux-specific performance tracking test
- * Tests each component individually to identify issues
- */
-import { performanceTracker } from './lib/performanceTracker.js';
-import { getTopProcesses } from './lib/topProcesses.js';
-import { logger, setVerbose } from './lib/logger.js';
-import pidusage from 'pidusage';
-import os from 'os';
-import fs from 'fs';
-// Enable verbose logging
-setVerbose(true);
-async function testPidUsage() {
-  logger.info('=== Testing pidusage ===');
-  try {
-    const stats = await pidusage(process.pid);
-    logger.info('pidusage SUCCESS', {
-      cpu: stats.cpu?.toFixed(2),
-      memory: (stats.memory / (1024 * 1024)).toFixed(1) + ' MB',
-      pid: stats.pid,
-      ppid: stats.ppid
-    });
-    return true;
-  } catch (error) {
-    logger.error('pidusage FAILED', { error: error.message, stack: error.stack });
-    return false;
-  }
-}
-async function testTopProcesses() {
-  logger.info('=== Testing getTopProcesses ===');
-  try {
-    const topProcs = await getTopProcesses(5);
-    logger.info('getTopProcesses SUCCESS', {
-      count: topProcs.length,
-      processes: topProcs.map(p => `${p.name} (PID: ${p.pid}, CPU: ${p.cpu}%)`)
-    });
-    return topProcs.length > 0;
-  } catch (error) {
-    logger.error('getTopProcesses FAILED', { error: error.message, stack: error.stack });
-    return false;
-  }
-}
-async function testNetworkMetrics() {
-  logger.info('=== Testing Network Metrics ===');
-  try {
-    if (process.platform === 'linux') {
-      // Test /proc/net/dev reading
-      if (fs.existsSync('/proc/net/dev')) {
-        const content = fs.readFileSync('/proc/net/dev', 'utf8');
-        const lines = content.split('\n');
-        let totalRx = 0;
-        let totalTx = 0;
-        logger.info('/proc/net/dev file found');
-        logger.debug('First few lines:', lines.slice(0, 5));
-        for (const line of lines) {
-          if (line.includes(':')) {
-            const parts = line.split(':')[1].trim().split(/\s+/);
-            if (parts.length >= 9) {
-              const rx = parseInt(parts[0]) || 0;
-              const tx = parseInt(parts[8]) || 0;
-              totalRx += rx;
-              totalTx += tx;
-            }
-          }
-        }
-        logger.info('Network stats parsed', {
-          totalRx: (totalRx / (1024 * 1024)).toFixed(2) + ' MB',
-          totalTx: (totalTx / (1024 * 1024)).toFixed(2) + ' MB'
-        });
-        return true;
-      } else {
-        logger.warn('/proc/net/dev not found - running in container?');
-        return false;
-      }
-    } else {
-      logger.info('Skipping network test (not Linux)');
-      return true;
-    }
-  } catch (error) {
-    logger.error('Network metrics FAILED', { error: error.message, stack: error.stack });
-    return false;
-  }
-}
-async function testSystemMetrics() {
-  logger.info('=== Testing System Metrics ===');
-  try {
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const usedMem = totalMem - freeMem;
-    const cpus = os.cpus();
-    logger.info('System metrics SUCCESS', {
-      totalMemory: (totalMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
-      freeMemory: (freeMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
-      usedMemory: (usedMem / (1024 * 1024 * 1024)).toFixed(2) + ' GB',
-      memoryUsagePercent: ((usedMem / totalMem) * 100).toFixed(1) + '%',
-      cpuCount: cpus.length,
-      platform: os.platform(),
-      arch: os.arch()
-    });
-    return true;
-  } catch (error) {
-    logger.error('System metrics FAILED', { error: error.message });
-    return false;
-  }
-}
-async function testPerformanceTracker() {
-  logger.info('=== Testing PerformanceTracker ===');
-  try {
-    logger.info('Starting performance tracker for 10 seconds...');
-    // Use temp directory for performance file
-    const tmpDir = os.tmpdir();
-    performanceTracker.start(tmpDir);
-    // Wait 10 seconds
-    await new Promise(resolve => setTimeout(resolve, 10000));
-    // Stop tracking
-    const result = performanceTracker.stop();
-    logger.info('PerformanceTracker stopped', {
-      sampleCount: result.samples?.length || 0,
-      hasSummary: !!result.summary
-    });
-    if (result.summary) {
-      logger.info('Performance Summary', {
-        duration: (result.summary.durationMs / 1000).toFixed(1) + 's',
-        avgCPU: result.summary.avgProcessCPU?.toFixed(1) + '%',
-        maxCPU: result.summary.maxProcessCPU?.toFixed(1) + '%',
-        avgMemory: result.summary.avgProcessMemoryMB?.toFixed(1) + ' MB',
-        maxMemory: result.summary.maxProcessMemoryMB?.toFixed(1) + ' MB'
-      });
-    }
-    if (result.samples && result.samples.length > 0) {
-      const lastSample = result.samples[result.samples.length - 1];
-      logger.info('Last sample data', {
-        hasSystem: !!lastSample.system,
-        hasProcess: !!lastSample.process,
-        hasNetwork: !!lastSample.network,
-        hasTopProcesses: !!lastSample.topProcesses,
-        topProcessesCount: lastSample.topProcesses?.length || 0
-      });
-      if (lastSample.topProcesses && lastSample.topProcesses.length > 0) {
-        logger.info('Top 3 processes from last sample:');
-        lastSample.topProcesses.slice(0, 3).forEach((proc, i) => {
-          logger.info(`  ${i + 1}. ${proc.name} - CPU: ${proc.cpu?.toFixed(1)}%, Mem: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
-        });
-      }
-    }
-    // Clean up
-    performanceTracker.cleanup();
-    return result.samples && result.samples.length > 0;
-  } catch (error) {
-    logger.error('PerformanceTracker FAILED', { error: error.message, stack: error.stack });
-    return false;
-  }
-}
-async function runAllTests() {
-  logger.info('Starting Linux Performance Tracking Tests');
-  logger.info('Platform:', os.platform());
-  logger.info('Architecture:', os.arch());
-  logger.info('Node version:', process.version);
-  logger.info('');
-  const results = {
-    pidusage: await testPidUsage(),
-    topProcesses: await testTopProcesses(),
-    networkMetrics: await testNetworkMetrics(),
-    systemMetrics: await testSystemMetrics(),
-    performanceTracker: await testPerformanceTracker()
-  };
-  logger.info('');
-  logger.info('=== Test Results Summary ===');
-  Object.entries(results).forEach(([test, passed]) => {
-    logger.info(`${test}: ${passed ? '✓ PASS' : '✗ FAIL'}`);
-  });
-  const allPassed = Object.values(results).every(r => r);
-  logger.info('');
-  logger.info(`Overall: ${allPassed ? '✓ ALL TESTS PASSED' : '✗ SOME TESTS FAILED'}`);
-  process.exit(allPassed ? 0 : 1);
-}
-runAllTests().catch(error => {
-  logger.error('Test suite failed', { error: error.message, stack: error.stack });
-  process.exit(1);
-});

package/test-perf-tracker.js DELETED Viewed

@@ -1,52 +0,0 @@
-#!/usr/bin/env node
-import { PerformanceTracker } from './lib/performanceTracker.js';
-import { logger, setVerbose } from './lib/logger.js';
-setVerbose(true);
-async function testPerformanceTracking() {
-  console.log('Testing performance tracking with top processes...\n');
-  const tracker = new PerformanceTracker();
-  // Start tracking
-  tracker.start();
-  console.log('Started tracking...');
-  // Wait for 6 seconds to get at least one sample
-  console.log('Waiting 6 seconds for sample...');
-  await new Promise(resolve => setTimeout(resolve, 6000));
-  // Stop tracking
-  const result = tracker.stop();
-  console.log('\n=== Performance Tracking Results ===');
-  console.log(`Total samples: ${result.samples.length}`);
-  if (result.samples.length > 0) {
-    const firstSample = result.samples[0];
-    console.log('\nFirst sample keys:', Object.keys(firstSample));
-    console.log('Has topProcesses:', !!firstSample.topProcesses);
-    console.log('topProcesses count:', firstSample.topProcesses?.length || 0);
-    if (firstSample.topProcesses && firstSample.topProcesses.length > 0) {
-      console.log('\nTop 3 processes:');
-      firstSample.topProcesses.slice(0, 3).forEach((proc, i) => {
-        console.log(`${i + 1}. ${proc.name} (PID: ${proc.pid})`);
-        console.log(`   CPU: ${proc.cpu.toFixed(1)}%`);
-        console.log(`   Memory: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
-      });
-    }
-  }
-  if (result.summary) {
-    console.log('\nSummary:');
-    console.log(`  Duration: ${(result.summary.durationMs / 1000).toFixed(1)}s`);
-    console.log(`  Sample count: ${result.summary.sampleCount}`);
-    console.log(`  Avg CPU: ${result.summary.avgProcessCPU.toFixed(1)}%`);
-    console.log(`  Max CPU: ${result.summary.maxProcessCPU.toFixed(1)}%`);
-  }
-}
-testPerformanceTracking().catch(console.error);

package/test-performance-tracking.js DELETED Viewed

@@ -1,108 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test script to verify performance tracking during recording
- */
-import { startRecording, stopRecording } from './lib/recorder.js';
-import { logger, setVerbose } from './lib/logger.js';
-import fs from 'fs';
-// Enable verbose logging
-setVerbose(true);
-async function testPerformanceTracking() {
-  try {
-    logger.info('Starting performance tracking test...');
-    // Start recording
-    logger.info('Starting recording...');
-    const startResult = await startRecording({
-      fps: 10,
-      includeAudio: false
-    });
-    logger.info('Recording started', {
-      outputPath: startResult.outputPath,
-      startTime: startResult.startTime
-    });
-    // Record for 10 seconds
-    logger.info('Recording for 10 seconds...');
-    await new Promise(resolve => setTimeout(resolve, 10000));
-    // Stop recording
-    logger.info('Stopping recording...');
-    const result = await stopRecording();
-    logger.info('Recording stopped successfully');
-    // Display performance results
-    if (result.performance) {
-      logger.info('=== Performance Tracking Results ===');
-      if (result.performance.summary) {
-        const summary = result.performance.summary;
-        logger.info('Summary Statistics:');
-        logger.info(`  Duration: ${(summary.durationMs / 1000).toFixed(1)}s`);
-        logger.info(`  Sample Count: ${summary.sampleCount}`);
-        logger.info(`  Monitor Interval: ${summary.monitorInterval}ms`);
-        logger.info('');
-        logger.info('Process Metrics:');
-        logger.info(`  Average CPU: ${summary.avgProcessCPU.toFixed(1)}%`);
-        logger.info(`  Max CPU: ${summary.maxProcessCPU.toFixed(1)}%`);
-        logger.info(`  Average Memory: ${summary.avgProcessMemoryMB.toFixed(1)} MB`);
-        logger.info(`  Max Memory: ${summary.maxProcessMemoryMB.toFixed(1)} MB`);
-        logger.info('');
-        logger.info('System Metrics:');
-        logger.info(`  Average System Memory Usage: ${summary.avgSystemMemoryUsagePercent.toFixed(1)}%`);
-        logger.info(`  Max System Memory Usage: ${summary.maxSystemMemoryUsagePercent.toFixed(1)}%`);
-        logger.info(`  Total System Memory: ${summary.totalSystemMemoryGB.toFixed(2)} GB`);
-      }
-      if (result.performance.samples && result.performance.samples.length > 0) {
-        logger.info('');
-        logger.info(`Collected ${result.performance.samples.length} performance samples`);
-        // Show top processes from the last sample
-        const lastSample = result.performance.samples[result.performance.samples.length - 1];
-        if (lastSample.topProcesses && lastSample.topProcesses.length > 0) {
-          logger.info('');
-          logger.info('Top 10 Processes (from last sample):');
-          lastSample.topProcesses.forEach((proc, index) => {
-            logger.info(`  ${index + 1}. ${proc.name} (PID: ${proc.pid})`);
-            logger.info(`     CPU: ${proc.cpu.toFixed(1)}%, Memory: ${(proc.memory / (1024 * 1024)).toFixed(1)} MB`);
-          });
-          logger.info(`Total processes on system: ${lastSample.totalProcesses}`);
-        }
-      }
-    } else {
-      logger.warn('No performance data in result');
-    }
-    // Display other results
-    logger.info('');
-    logger.info('=== Recording Results ===');
-    logger.info(`Output: ${result.outputPath}`);
-    logger.info(`Duration: ${result.duration}ms`);
-    logger.info(`File Size: ${(result.fileSize / 1024 / 1024).toFixed(2)} MB`);
-    logger.info(`Apps Tracked: ${result.apps?.length || 0}`);
-    logger.info(`Log Events: ${result.logs?.reduce((sum, log) => sum + log.count, 0) || 0}`);
-    // Verify file exists
-    if (fs.existsSync(result.outputPath)) {
-      logger.info('Recording file created successfully');
-    } else {
-      logger.error('Recording file not found!');
-    }
-    logger.info('Test completed successfully!');
-  } catch (error) {
-    logger.error('Test failed:', error);
-    process.exit(1);
-  }
-}
-// Run the test
-testPerformanceTracking();

package/test-short-recording.js DELETED Viewed

@@ -1,287 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test script for analyzing short recording issues
- *
- * This tests whether very short recordings produce valid multi-frame videos
- * with properly finalized WebM container metadata.
- *
- * Known issue: If ffmpeg/VP9 encoder is killed too quickly, the WebM container
- * metadata (especially duration) may be incomplete, causing playback issues.
- *
- * Usage:
- *   node test-short-recording.js                    # Run recording tests
- *   node test-short-recording.js analyze <file>     # Analyze existing video
- *   node test-short-recording.js fix <input> <output> # Fix broken video container
- *
- * Platform notes:
- *   - macOS: Uses AVFoundation for screen capture
- *   - Linux: Uses X11grab for screen capture
- *   - Windows: Uses gdigrab for screen capture
- */
-import { startRecording, stopRecording, fixVideoContainer } from './lib/recorder.js';
-import { execa } from 'execa';
-import { getFfprobePath } from './lib/binaries.js';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-async function analyzeVideo(videoPath) {
-  const ffprobePath = await getFfprobePath();
-  console.log(`\nAnalyzing video: ${videoPath}`);
-  console.log('='.repeat(80));
-  // Check if file exists
-  if (!fs.existsSync(videoPath)) {
-    console.error(`Video file does not exist: ${videoPath}`);
-    return null;
-  }
-  const stats = fs.statSync(videoPath);
-  console.log(`File size: ${(stats.size / 1024).toFixed(2)} KB`);
-  try {
-    // Get basic format info
-    const formatResult = await execa(ffprobePath, [
-      '-v', 'error',
-      '-show_entries', 'format=duration,size,bit_rate',
-      '-of', 'json',
-      videoPath
-    ]);
-    const formatData = JSON.parse(formatResult.stdout);
-    console.log(`Duration: ${formatData.format.duration || 'unknown'}s`);
-    console.log(`Bit rate: ${formatData.format.bit_rate || 'unknown'} bits/s`);
-    // Get stream info
-    const streamResult = await execa(ffprobePath, [
-      '-v', 'error',
-      '-show_entries', 'stream=codec_name,width,height,r_frame_rate,duration',
-      '-of', 'json',
-      videoPath
-    ]);
-    const streamData = JSON.parse(streamResult.stdout);
-    const videoStream = streamData.streams.find(s => s.codec_name);
-    if (videoStream) {
-      console.log(`Codec: ${videoStream.codec_name}`);
-      console.log(`Resolution: ${videoStream.width}x${videoStream.height}`);
-      console.log(`Frame rate: ${videoStream.r_frame_rate}`);
-    }
-    // Count actual frames
-    const frameResult = await execa(ffprobePath, [
-      '-v', 'error',
-      '-count_frames',
-      '-select_streams', 'v:0',
-      '-show_entries', 'stream=nb_read_frames',
-      '-of', 'default=nokey=1:noprint_wrappers=1',
-      videoPath
-    ], { reject: false });
-    const frameCount = parseInt(frameResult.stdout.trim());
-    console.log(`Frame count: ${frameCount || 'unknown'}`);
-    if (frameResult.stderr) {
-      console.log(`FFprobe warnings: ${frameResult.stderr.trim()}`);
-    }
-    // Check if duration is available in container
-    const hasDuration = formatData.format.duration && !isNaN(parseFloat(formatData.format.duration));
-    // Determine if this is a single-frame video issue
-    const isSingleFrame = frameCount === 1;
-    const hasEncodingIssues = frameResult.stderr.includes('File ended prematurely');
-    const hasMissingMetadata = !hasDuration;
-    console.log('\nAnalysis Result:');
-    console.log(`   Single frame: ${isSingleFrame ? 'YES (BUG!)' : 'NO'}`);
-    console.log(`   Encoding issues: ${hasEncodingIssues ? 'YES' : 'NO'}`);
-    console.log(`   Missing metadata: ${hasMissingMetadata ? 'YES (container incomplete)' : 'NO'}`);
-    console.log(`   Platform: ${os.platform()}`);
-    return {
-      exists: true,
-      size: stats.size,
-      duration: parseFloat(formatData.format.duration),
-      frameCount,
-      codec: videoStream?.codec_name,
-      resolution: videoStream ? `${videoStream.width}x${videoStream.height}` : 'unknown',
-      isSingleFrame,
-      hasEncodingIssues,
-      hasMissingMetadata,
-      platform: os.platform()
-    };
-  } catch (error) {
-    console.error(`Error analyzing video: ${error.message}`);
-    return null;
-  }
-}
-async function testShortRecording(duration = 3000) {
-  console.log(`\nTesting ${duration}ms recording...`);
-  console.log('='.repeat(80));
-  try {
-    // Start recording
-    console.log('Starting recording...');
-    const { outputPath, startTime } = await startRecording({
-      fps: 30,
-      includeAudio: false
-    });
-    console.log(`Recording started at: ${outputPath}`);
-    // Wait for specified duration
-    console.log(`Recording for ${duration}ms...`);
-    await new Promise(resolve => setTimeout(resolve, duration));
-    // Stop recording
-    console.log('Stopping recording...');
-    const result = await stopRecording();
-    console.log(`Recording stopped`);
-    console.log(`   Duration: ${result.duration}ms`);
-    console.log(`   File: ${result.outputPath}`);
-    // Analyze the output
-    await analyzeVideo(result.outputPath);
-    return result;
-  } catch (error) {
-    console.error(`Test failed: ${error.message}`);
-    console.error(error.stack);
-    throw error;
-  }
-}
-async function testExistingVideo(videoPath) {
-  console.log('\nTesting existing video...');
-  console.log('='.repeat(80));
-  return await analyzeVideo(videoPath);
-}
-// Main test runner
-async function main() {
-  const args = process.argv.slice(2);
-  console.log('\nShort Recording Test Suite');
-  console.log('='.repeat(80));
-  console.log(`Platform: ${os.platform()}`);
-  console.log(`Architecture: ${os.arch()}`);
-  console.log(`Node version: ${process.version}`);
-  if (args[0] === 'analyze' && args[1]) {
-    // Analyze existing video
-    const videoPath = path.resolve(args[1]);
-    const result = await testExistingVideo(videoPath);
-    if (result?.isSingleFrame) {
-      console.log('\nSINGLE-FRAME VIDEO DETECTED!');
-      process.exit(1);
-    } else if (result?.hasMissingMetadata) {
-      console.log('\nWARNING: Video container metadata is incomplete!');
-      console.log('   This can cause playback issues in some players.');
-      console.log('   The video has frames but duration is not in the container.');
-      console.log('\nTry fixing it with:');
-      console.log(`   node test-short-recording.js fix ${args[1]} ${args[1].replace(/\.(webm|mp4)$/, '-fixed.$1')}`);
-      process.exit(1);
-    }
-  } else if (args[0] === 'fix' && args[1] && args[2]) {
-    // Fix existing broken video
-    const inputPath = path.resolve(args[1]);
-    const outputPath = path.resolve(args[2]);
-    console.log('\nFixing video container...');
-    console.log('='.repeat(80));
-    console.log(`Input:  ${inputPath}`);
-    console.log(`Output: ${outputPath}`);
-    if (!fs.existsSync(inputPath)) {
-      console.error(`Input file does not exist: ${inputPath}`);
-      process.exit(1);
-    }
-    // Analyze before
-    console.log('\nBEFORE:');
-    const beforeResult = await analyzeVideo(inputPath);
-    // Fix the video
-    const fixSuccess = await fixVideoContainer(inputPath, outputPath);
-    if (!fixSuccess) {
-      console.error('\nFailed to fix video!');
-      process.exit(1);
-    }
-    // Analyze after
-    console.log('\nAFTER:');
-    const afterResult = await analyzeVideo(outputPath);
-    console.log('\nVideo fixed successfully!');
-    console.log(`   Before: ${beforeResult?.hasMissingMetadata ? 'Missing metadata' : 'Has metadata'}`);
-    console.log(`   After:  ${afterResult?.hasMissingMetadata ? 'Missing metadata' : 'Has metadata'}`);
-    if (afterResult?.hasMissingMetadata) {
-      console.log('\nWarning: Metadata still missing after fix. The source file may be corrupted.');
-      process.exit(1);
-    }
-  } else {
-    // Run recording tests with different durations
-    const testDurations = [1000, 2000, 3000, 5000];
-    const results = [];
-    for (const duration of testDurations) {
-      try {
-        const result = await testShortRecording(duration);
-        results.push({ duration, success: true, result });
-        // Clean up
-        try {
-          fs.unlinkSync(result.outputPath);
-          if (result.gifPath && fs.existsSync(result.gifPath)) {
-            fs.unlinkSync(result.gifPath);
-          }
-          if (result.snapshotPath && fs.existsSync(result.snapshotPath)) {
-            fs.unlinkSync(result.snapshotPath);
-          }
-        } catch (cleanupError) {
-          console.warn(`Cleanup warning: ${cleanupError.message}`);
-        }
-      } catch (error) {
-        results.push({ duration, success: false, error: error.message });
-      }
-      // Wait between tests
-      await new Promise(resolve => setTimeout(resolve, 2000));
-    }
-    // Summary
-    console.log('\n\nTEST SUMMARY');
-    console.log('='.repeat(80));
-    for (const result of results) {
-      const status = result.success ? 'PASS' : 'FAIL';
-      console.log(`${status} ${result.duration}ms recording: ${result.success ? 'PASSED' : result.error}`);
-    }
-    const allPassed = results.every(r => r.success);
-    if (!allPassed) {
-      console.log('\nSome tests failed!');
-      process.exit(1);
-    } else {
-      console.log('\nAll tests passed!');
-    }
-  }
-}
-main().catch(error => {
-  console.error('Fatal error:', error);
-  process.exit(1);
-});

package/test-top-processes.js DELETED Viewed

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-import { getTopProcesses } from './lib/topProcesses.js';
-import { logger, setVerbose } from './lib/logger.js';
-setVerbose(true);
-async function test() {
-  console.log('Testing getTopProcesses...\n');
-  const processes = await getTopProcesses(10);
-  console.log(`Found ${processes.length} processes:\n`);
-  processes.forEach((proc, index) => {
-    console.log(`${index + 1}. ${proc.name} (PID: ${proc.pid})`);
-    console.log(`   CPU: ${proc.cpu}%`);
-    console.log(`   Memory: ${proc.mem || proc.memBytes}${proc.memBytes ? ' bytes' : '%'}`);
-    console.log();
-  });
-}
-test().catch(console.error);

package/test.log DELETED Viewed

	@@ -1 +0,0 @@
1	- {"message": "test log entry", "level": "info", "timestamp": 1761692597000}