### Install @paulcbetts/system-idle-time

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Installs the system idle time Node.js module using npm. This is the primary step to integrate the library into your project.

```bash
npm install @paulcbetts/system-idle-time
```

--------------------------------

### Install Linux X11 Screensaver Dependencies

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Installs the necessary X11 screensaver extension libraries required for the system-idle-time module to function on Linux systems. This is a prerequisite for Linux installations.

```bash
# Debian/Ubuntu
sudo apt-get install libxss-dev

# Fedora/RHEL
sudo dnf install libXScrnSaver-devel
```

--------------------------------

### Get System Idle Time in Milliseconds (JavaScript)

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Retrieves the current system idle time in milliseconds using the getIdleTime() function from the @paulcbetts/system-idle-time module. This is the core functionality of the library.

```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');

// Get current idle time in milliseconds
const idleMs = systemIdleTime.getIdleTime();
console.log(`System has been idle for ${idleMs}ms`);
// Output: System has been idle for 5234ms
```

--------------------------------

### System Idle Time API Reference

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

This section details the primary function for retrieving system idle time.

```APIDOC
## GET /getIdleTime

### Description
Returns the number of milliseconds since the last user input (keyboard, mouse, or other input device activity). This is the only function exported by the module and provides cross-platform idle detection.

### Method
GET

### Endpoint
/getIdleTime

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');

// Get current idle time in milliseconds
const idleMs = systemIdleTime.getIdleTime();
console.log(`System has been idle for ${idleMs}ms`);
// Output: System has been idle for 5234ms
```

### Response
#### Success Response (200)
- **idleMs** (integer) - The number of milliseconds since the last user input.

#### Response Example
```json
{
  "idleMs": 5234
}
```
```

--------------------------------

### Poll System Idle Time Periodically (JavaScript)

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Demonstrates how to continuously monitor system idle time at regular intervals (e.g., every second) using setInterval. This is useful for real-time inactivity tracking.

```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');

// Poll idle time every second
const pollInterval = setInterval(() => {
  const idleMs = systemIdleTime.getIdleTime();
  const idleSeconds = Math.floor(idleMs / 1000);
  console.log(`Idle time: ${idleSeconds} seconds`);
}, 1000);

// Stop polling after 30 seconds
setTimeout(() => {
  clearInterval(pollInterval);
  console.log('Stopped monitoring');
}, 30000);
```

--------------------------------

### Event-Based Idle Detection with EventEmitter (JavaScript)

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Creates a custom IdleMonitor class that extends Node.js's EventEmitter to emit 'idle' and 'active' events when the system idle state changes. This allows for a more reactive and decoupled approach to managing idle states.

```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');
const EventEmitter = require('events');

class IdleMonitor extends EventEmitter {
  constructor(thresholdMs = 60000, pollIntervalMs = 1000) {
    super();
    this.thresholdMs = thresholdMs;
    this.pollIntervalMs = pollIntervalMs;
    this.isIdle = false;
    this.timer = null;
  }

  start() {
    this.timer = setInterval(() => {
      const idleMs = systemIdleTime.getIdleTime();
      const nowIdle = idleMs >= this.thresholdMs;

      if (nowIdle !== this.isIdle) {
        this.isIdle = nowIdle;
        this.emit(nowIdle ? 'idle' : 'active', { idleMs });
      }

      this.emit('tick', { idleMs, isIdle: this.isIdle });
    }, this.pollIntervalMs);
  }

  stop() {
    if (this.timer) {
      clearInterval(this.timer);
      this.timer = null;
    }
  }
}

// Usage: Alert after 2 minutes of inactivity
const monitor = new IdleMonitor(2 * 60 * 1000);

monitor.on('idle', ({ idleMs }) => {
  console.log(`User went idle after ${idleMs}ms`);
});

monitor.on('active', () => {
  console.log('User is back!');
});

monitor.start();
```

--------------------------------

### Promise-Based Idle Time Wrapper (JavaScript)

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Wraps the synchronous getIdleTime() function in a Promise to enable its use with modern async/await syntax. This provides a cleaner way to handle asynchronous operations related to idle time.

```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');

function getIdleTimeAsync() {
  return new Promise((resolve) => {
    resolve(systemIdleTime.getIdleTime());
  });
}

async function checkIdleStatus() {
  const idleMs = await getIdleTimeAsync();
  const idleMinutes = (idleMs / 1000 / 60).toFixed(2);

  return {
    milliseconds: idleMs,
    seconds: Math.floor(idleMs / 1000),
    minutes: parseFloat(idleMinutes),
    isActive: idleMs < 30000 // Active if less than 30 seconds idle
  };
}

// Usage
checkIdleStatus().then(status => {
  console.log(status);
  // { milliseconds: 12500, seconds: 12, minutes: 0.21, isActive: true }
});
```

--------------------------------

### Detect Idle Threshold and Trigger Actions (JavaScript)

Source: https://context7.com/paulcbetts/node-system-idle-time/llms.txt

Implements logic to detect when the system idle time exceeds a predefined threshold (e.g., 5 minutes) and trigger specific actions, such as pausing background tasks. This is useful for implementing auto-logout or resource management.

```javascript
const systemIdleTime = require('@paulcbetts/system-idle-time');

const IDLE_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
let wasIdle = false;

setInterval(() => {
  const idleMs = systemIdleTime.getIdleTime();
  const isIdle = idleMs >= IDLE_THRESHOLD_MS;

  if (isIdle && !wasIdle) {
    console.log('User became idle - pausing background tasks');
    // Trigger idle actions: pause sync, reduce polling, etc.
  } else if (!isIdle && wasIdle) {
    console.log('User returned - resuming background tasks');
    // Resume normal operations
  }

  wasIdle = isIdle;
}, 1000);
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.