dashcam 1.4.2-beta → 1.4.5-beta

package/lib/recorder.js

@@ -4,6 +4,7 @@ import { createGif, createSnapshot } from './ffmpeg.js';
 import { applicationTracker } from './applicationTracker.js';
 import { logsTrackerManager, trimLogs } from './logs/index.js';
 import { getFfmpegPath, getFfprobePath } from './binaries.js';
+import { performanceTracker } from './performanceTracker.js';
 import path from 'path';
 import os from 'os';
 import fs from 'fs';
@@ -328,14 +329,14 @@ export async function startRecording({
   const outputArgs = [
     // Convert pixel format first to handle transparency issues on Windows
     '-pix_fmt', 'yuv420p',  // Force YUV420P format (no alpha channel)
-    '-c:v', 'libvpx',  // Use VP9 codec for better quality and compression
+    '-c:v', 'libvpx',  // Use VP8 codec (not VP9) for lower CPU usage
     '-quality', 'realtime', // Use realtime quality preset for faster encoding
     '-cpu-used', '8',       // Maximum speed (0-8, higher = faster but lower quality)
     '-deadline', 'realtime',// Realtime encoding mode for lowest latency
-    '-b:v', '2M',           // Target bitrate
+    '-b:v', '1M',           // Reduced bitrate to 1M (from 2M) to lower CPU usage
     '-r', fps.toString(),   // Ensure output framerate matches input
-    '-g', fps.toString(),   // Keyframe interval = 1 second (every fps frames) - ensures frequent keyframes
-    '-force_key_frames', `expr:gte(t,n_forced*1)`, // Force keyframe every 1 second
+    '-g', (fps * 2).toString(),   // Keyframe interval = 2 seconds (reduced frequency)
+    '-threads', '2',        // Limit thread count to reduce CPU usage
     '-auto-alt-ref', '0',   // Disable auto alternate reference frames (fixes transparency encoding error)
     // WebM options for more frequent disk writes and proper stream handling
     '-f', 'webm',           // Force WebM container format
@@ -343,7 +344,7 @@ export async function startRecording({
     '-fflags', '+genpts',   // Generate presentation timestamps
     '-avoid_negative_ts', 'make_zero', // Avoid negative timestamps
     '-vsync', '1',          // Ensure every frame is encoded (CFR - constant frame rate)
-    '-max_muxing_queue_size', '9999' // Large queue to prevent frame drops
+    '-max_muxing_queue_size', '1024' // Reduced queue size to lower memory usage
   ];
 
   if (includeAudio) {
@@ -414,19 +415,12 @@ export async function startRecording({
       reject: false,
       all: true, // Capture both stdout and stderr
       stdin: 'pipe', // Enable stdin for sending 'q' to stop recording
-      detached: false,
+      detached: false, // Keep attached so it dies with parent
       windowsHide: true // Hide the console window on Windows
     });
     
-    // Unref the child process so it doesn't keep the parent alive
-    if (currentRecording.pid) {
-      try {
-        currentRecording.unref();
-      } catch (e) {
-        // Ignore errors if unref is not available
-        logger.debug('Could not unref ffmpeg process');
-      }
-    }
+    // Don't unref - we want FFmpeg to be killed when parent dies
+    // Removing unref() ensures orphaned processes don't hang around
     
     logger.info('FFmpeg process spawned', { 
       pid: currentRecording.pid,
@@ -450,6 +444,11 @@ export async function startRecording({
     logger.debug('Starting application tracking...');
     applicationTracker.start();
     
+    // Start performance tracking - pass output directory for file storage
+    logger.debug('Starting performance tracking...');
+    const outputDir = path.dirname(outputPath);
+    performanceTracker.start(outputDir);
+    
     // Start log tracking for this recording (don't await to avoid blocking)
     const recorderId = path.basename(outputPath).replace('.webm', '');
     logger.debug('Starting log tracking...', { recorderId });
@@ -724,7 +723,8 @@ export async function stopRecording() {
           clientStartDate: recordingStartTime,
           apps: applicationTracker.stop().apps,
           icons: applicationTracker.stop().icons,
-          logs: await logsTrackerManager.stop({ recorderId: path.basename(outputPath).replace('.webm', ''), screenId: '1' })
+          logs: await logsTrackerManager.stop({ recorderId: path.basename(outputPath).replace('.webm', ''), screenId: '1' }),
+          performance: performanceTracker.stop()
         };
         
         currentRecording = null;
@@ -799,6 +799,10 @@ export async function stopRecording() {
     logger.debug('Stopping application tracking...');
     const appTrackingResults = applicationTracker.stop();
     
+    // Stop performance tracking and get results
+    logger.debug('Stopping performance tracking...');
+    const performanceResults = performanceTracker.stop();
+    
     // Stop log tracking and get results
     const recorderId = path.basename(outputPath).replace('.webm', '');
     logger.debug('Stopping log tracking...', { recorderId });
@@ -816,6 +820,11 @@ export async function stopRecording() {
       logResults: {
         trackers: logTrackingResults.length,
         totalEvents: logTrackingResults.reduce((sum, result) => sum + result.count, 0)
+      },
+      performanceResults: {
+        sampleCount: performanceResults.summary?.sampleCount || 0,
+        avgProcessCPU: performanceResults.summary?.avgProcessCPU?.toFixed(1) || 0,
+        avgProcessMemoryMB: performanceResults.summary?.avgProcessMemoryMB?.toFixed(1) || 0
       }
     });
 
@@ -847,13 +856,19 @@ export async function stopRecording() {
       clientStartDate: recordingStartTime, // Include the recording start timestamp
       apps: appTrackingResults.apps, // Include tracked applications
       icons: appTrackingResults.icons, // Include application icons metadata
-      logs: logTrackingResults // Include log tracking results
+      logs: logTrackingResults, // Include log tracking results
+      performance: performanceResults // Include performance tracking results
     };
     
-    logger.info('Recording stopped with clientStartDate', {
+    logger.info('Recording stopped with performance data', {
       clientStartDate: recordingStartTime,
       clientStartDateReadable: new Date(recordingStartTime).toISOString(),
-      duration: result.duration
+      duration: result.duration,
+      performanceSamples: performanceResults.summary?.sampleCount || 0,
+      avgCPU: performanceResults.summary?.avgProcessCPU?.toFixed(1) || 0,
+      maxCPU: performanceResults.summary?.maxProcessCPU?.toFixed(1) || 0,
+      avgMemoryMB: performanceResults.summary?.avgProcessMemoryMB?.toFixed(1) || 0,
+      maxMemoryMB: performanceResults.summary?.maxProcessMemoryMB?.toFixed(1) || 0
     });
 
     currentRecording = null;
@@ -888,6 +903,12 @@ export async function stopRecording() {
     
     // Stop application tracking on error
     applicationTracker.stop();
+    
+    // Stop performance tracking on error
+    if (performanceTracker.isTracking()) {
+      performanceTracker.stop();
+    }
+    
     throw error;
   }
 }

package/lib/topProcesses.js

@@ -0,0 +1,128 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import os from 'os';
+import { logger } from './logger.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Parse ps output format: "  PID %CPU %MEM COMMAND"
+ */
+function parsePsOutput(stdout, limit) {
+  const lines = stdout.trim().split('\n');
+  // Skip header line
+  return lines.slice(1, 1 + limit).map(line => {
+    const parts = line.trim().split(/\s+/, 4);
+    return {
+      pid: Number(parts[0]),
+      cpu: Number(parts[1]),
+      mem: Number(parts[2]),
+      name: parts[3] || ''
+    };
+  });
+}
+
+/**
+ * Get top processes on Unix-like systems (Linux, macOS)
+ */
+async function getTopProcessesUnix(limit = 10) {
+  try {
+    let stdout;
+    
+    if (os.platform() === 'darwin') {
+      // macOS uses BSD ps - different syntax, no --sort option
+      // Use -r flag to sort by CPU usage
+      const result = await execFileAsync('ps', [
+        '-Arco',
+        'pid,pcpu,pmem,comm'
+      ], { encoding: 'utf8' });
+      stdout = result.stdout;
+    } else {
+      // Linux uses GNU ps - supports --sort
+      const result = await execFileAsync('ps', [
+        '-eo',
+        'pid,pcpu,pmem,comm',
+        '--sort=-pcpu'
+      ], { encoding: 'utf8' });
+      stdout = result.stdout;
+    }
+    
+    return parsePsOutput(stdout, limit);
+  } catch (error) {
+    logger.warn('Failed to get top processes on Unix', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Parse PowerShell JSON output for Windows processes
+ */
+function parsePsWinJson(stdout, limit) {
+  let arr;
+  try {
+    arr = JSON.parse(stdout);
+  } catch (e) {
+    logger.warn('Failed to parse PowerShell JSON output', { error: e.message });
+    return [];
+  }
+  
+  if (!Array.isArray(arr)) {
+    arr = [arr];
+  }
+
+  // Some fields may be undefined if CPU hasn't updated yet
+  arr.sort((a, b) => (b.CPU || 0) - (a.CPU || 0));
+
+  return arr.slice(0, limit).map(p => ({
+    pid: p.Id,
+    cpu: p.CPU || 0,              // total CPU seconds
+    memBytes: p.WS || 0,          // working set in bytes
+    name: p.ProcessName || ''
+  }));
+}
+
+/**
+ * Get top processes on Windows using PowerShell
+ */
+async function getTopProcessesWindows(limit = 10) {
+  try {
+    // Use PowerShell to get process info and convert to JSON
+    // NOTE: PowerShell startup is slower but more reliable than WMI
+    const psCmd = [
+      'Get-Process | ',
+      'Select-Object Id,CPU,WS,ProcessName | ',
+      'ConvertTo-Json'
+    ].join('');
+
+    const { stdout } = await execFileAsync('powershell.exe', [
+      '-NoLogo',
+      '-NoProfile',
+      '-NonInteractive',
+      '-Command',
+      psCmd
+    ], { encoding: 'utf8' });
+
+    return parsePsWinJson(stdout, limit);
+  } catch (error) {
+    logger.warn('Failed to get top processes on Windows', { error: error.message });
+    return [];
+  }
+}
+
+/**
+ * Get top processes by CPU usage (cross-platform)
+ * @param {number} limit - Number of top processes to return (default: 10)
+ * @returns {Promise<Array>} Array of process objects with pid, cpu, mem/memBytes, and name
+ */
+export async function getTopProcesses(limit = 10) {
+  const platform = os.platform();
+  
+  logger.debug('Getting top processes', { platform, limit });
+  
+  if (platform === 'win32') {
+    return getTopProcessesWindows(limit);
+  }
+  
+  // Linux, macOS, and other Unix-like systems
+  return getTopProcessesUnix(limit);
+}

package/lib/uploader.js

@@ -6,6 +6,7 @@ import path from 'path';
 import { auth } from './auth.js';
 import got from 'got';
 import { getSystemInfo } from './systemInfo.js';
+import { API_ENDPOINT } from './config.js';
 
 class Uploader {
   constructor() {
@@ -250,7 +251,8 @@ export async function upload(filePath, metadata = {}) {
     apps: metadata.apps && metadata.apps.length > 0 ? metadata.apps : ['Screen Recording'], // Use tracked apps or fallback
     title: metadata.title || defaultTitle,
     system: systemInfo, // Include system information
-    clientStartDate: metadata.clientStartDate || Date.now() // Use actual recording start time
+    clientStartDate: metadata.clientStartDate || Date.now(), // Use actual recording start time
+    performance: metadata.performance // Include performance tracking data
   };
 
   // Add project if we have one
@@ -262,18 +264,28 @@ export async function upload(filePath, metadata = {}) {
     replayConfig.description = metadata.description;
   }
 
-  logger.verbose('Creating replay with config', replayConfig);
+  logger.verbose('Creating replay with config', {
+    ...replayConfig,
+    performanceSamples: replayConfig.performance?.samples?.length || 0,
+    performanceSummary: replayConfig.performance?.summary ? 'included' : 'none'
+  });
 
   console.log('Creating replay on server...');
-  logger.info('Creating replay', replayConfig);
+  logger.info('Creating replay', {
+    title: replayConfig.title,
+    duration: replayConfig.duration,
+    apps: replayConfig.apps,
+    hasPerformanceData: !!replayConfig.performance,
+    performanceSamples: replayConfig.performance?.samples?.length || 0
+  });
 
   // Create the replay first
   const token = await auth.getToken();
   
   let newReplay;
   try {
-    logger.debug('Sending replay creation request...');
-    newReplay = await got.post('https://testdriver-api.onrender.com/api/v1/replay', {
+    logger.debug('Sending replay creation request...', { apiEndpoint: API_ENDPOINT });
+    newReplay = await got.post(`${API_ENDPOINT}/api/v1/replay`, {
       headers: {
         Authorization: `Bearer ${token}`
       },
@@ -459,7 +471,7 @@ export async function upload(filePath, metadata = {}) {
   console.log('Publishing replay...');
   
   try {
-    await got.post('https://testdriver-api.onrender.com/api/v1/replay/publish', {
+    await got.post(`${API_ENDPOINT}/api/v1/replay/publish`, {
       headers: {
         Authorization: `Bearer ${token}`
       },

package/lib/utilities/jsonl.js

@@ -62,14 +62,23 @@ export const jsonl = {
         let fd = fs.openSync(file, 'w');
         fs.closeSync(fd);
       } catch (error) {
-        throttledLog('info', `jsonl.js failed to initialize file ${error}`);
+        throttledLog('info', `jsonl.js failed to initialize file ${error.message}`, {
+          directory,
+          fileName,
+          error: error.message
+        });
+        throw error;
       }
     }
     try {
       let data = arrayOfJsonObjects.map((x) => JSON.stringify(x)).join('\n');
       fs.writeFileSync(file, data);
     } catch (error) {
-      throttledLog('info', `jsonl.js failed to write to file ${error}`);
+      throttledLog('info', `jsonl.js failed to write to file ${error.message}`, {
+        file,
+        error: error.message
+      });
+      throw error;
     }
 
     return file;

package/lib/websocket/server.js

@@ -51,7 +51,7 @@ class WSServer {
       return;
     }
     
-    logger.debug('WebSocketServer: Starting server, trying ports...', { ports: this.ports });
+    logger.info('WebSocketServer: Starting server, trying ports...', { ports: this.ports });
     for (const port of this.ports) {
       const ws = await new Promise((resolve) => {
         logger.debug('WebSocketServer: Trying port ' + port);
@@ -104,7 +104,11 @@ class WSServer {
     });
 
     this.#socket.on('connection', (client) => {
-      logger.info('WebSocketServer: New client connection established');
+      logger.info('WebSocketServer: New client connection established', {
+        clientAddress: client._socket?.remoteAddress,
+        clientPort: client._socket?.remotePort,
+        totalClients: this.#socket.clients.size
+      });
       
       let state = states.NEW;
       const failValidation = () => {
@@ -124,17 +128,22 @@ class WSServer {
 
       client.on('message', (data, isBinary) => {
         let message = isBinary ? data : data.toString();
-        logger.debug('WebSocketServer: Received message from client', { 
+        logger.info('WebSocketServer: Received message from client', { 
           isBinary, 
           messageLength: message.length,
+          messagePreview: message.substring(0, 100),
           state 
         });
         
         try {
           message = JSON.parse(message);
-          logger.debug('WebSocketServer: Parsed message', { type: message.type, hasPayload: !!message.payload });
+          logger.info('WebSocketServer: Parsed message', { 
+            type: message.type, 
+            hasPayload: !!message.payload,
+            payloadKeys: message.payload ? Object.keys(message.payload) : []
+          });
         } catch (err) {
-          logger.debug('WebSocketServer: Message is not JSON, treating as raw string');
+          logger.info('WebSocketServer: Message is not JSON, treating as raw string', { rawMessage: message });
         }
         
         if (state === states.SENT_HEADERS) {
@@ -152,14 +161,14 @@ class WSServer {
         this.emit('message', message, client);
       });
 
-      logger.debug('WebSocketServer: Sending connection header to client');
+      logger.info('WebSocketServer: Sending connection header to client');
       client.send('dashcam_desktop_socket_connected', (err) => {
         if (err) {
           logger.error('WebSocketServer: Failed to send connection header', { error: err.message });
           client.close();
           clearTimeout(timeout);
         } else {
-          logger.debug('WebSocketServer: Connection header sent, waiting for confirmation');
+          logger.info('WebSocketServer: Connection header sent, waiting for confirmation');
           state = states.SENT_HEADERS;
         }
       });
@@ -176,9 +185,10 @@ class WSServer {
       throw new Error('Server not currently running');
     }
     
-    logger.debug('WebSocketServer: Broadcasting message to all clients', { 
+    logger.info('WebSocketServer: Broadcasting message to all clients', { 
       clientCount: this.#socket.clients.size,
-      messageType: message.type || 'raw'
+      messageType: message.type || 'raw',
+      messagePayload: message.payload ? JSON.stringify(message.payload).substring(0, 100) : 'none'
     });
     
     this.#socket.clients.forEach((client) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dashcam",
-  "version": "1.4.2-beta",
+  "version": "1.4.5-beta",
   "description": "Minimal CLI version of Dashcam desktop app",
   "main": "bin/dashcam.js",
   "bin": {
@@ -47,6 +47,7 @@
     "mask-sensitive-data": "^0.11.5",
     "node-fetch": "^2.7.0",
     "open": "^9.1.0",
+    "pidusage": "^3.0.2",
     "systeminformation": "^5.18.15",
     "tail": "^2.2.6",
     "winston": "^3.11.0",

package/test-perf-tracker.js

@@ -0,0 +1,52 @@
+#!/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

@@ -0,0 +1,108 @@
+#!/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-top-processes.js

@@ -0,0 +1,23 @@
+#!/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);