# Where DesktopCommanderMCP Stores Tool Call Logs: Audit Logging Across macOS, Linux, and Windows

> Discover where DesktopCommanderMCP stores tool call logs. Learn about its cross-platform audit logging on macOS, Linux, and Windows at ~/.claude-server-commander/tool-history.jsonl.

- Repository: [Eduard Ruzga/DesktopCommanderMCP](https://github.com/wonderwhy-er/DesktopCommanderMCP)
- Tags: how-to-guide
- Published: 2026-08-01

---

**DesktopCommanderMCP stores every tool invocation in a JSONL audit file at `~/.claude-server-commander/tool-history.jsonl`, using `os.homedir()` to ensure the same logging mechanism works identically on macOS, Linux, and Windows.**

DesktopCommanderMCP is a Model Context Protocol (MCP) server that provides desktop automation capabilities. Understanding where **tool call logs** are stored and how the **audit logging** system functions across different operating systems is essential for debugging and compliance. The implementation uses a platform-agnostic approach that writes to the user's home directory regardless of the underlying OS.

## Audit Log Storage Location and File Format

The primary audit store is implemented in [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts).

The system constructs the log file path using Node.js's `os.homedir()` method:

```typescript
import * as os from 'os';
import * as path from 'path';

const historyFile = path.join(os.homedir(), '.claude-server-commander', 'tool-history.jsonl');

```

Each entry is appended as a JSON object containing the timestamp, tool name, arguments, output, and optional duration. The file uses **JSON Lines (JSONL)** format, where each line represents a complete JSON record.

## How the Audit Logging Mechanism Works

The `ToolHistory` class in [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts) manages the audit trail through several key mechanisms.

### The addCall Method

When a tool executes, the `addCall` method creates a `ToolCallRecord` and queues it for persistence:

```typescript
import { toolHistory } from './utils/toolHistory';

// After tool execution
const result = await someTool.run(args);
toolHistory.addCall('someTool', args, result, Date.now() - start);

```

This method pushes the record into a bounded in-memory array (maximum **1,000 entries**) and schedules an asynchronous disk flush via `flushToDisk()`.

### File Size Management

The audit system enforces storage limits to prevent unbounded growth:

- **Maximum file size**: 5 MiB
- **Target size after trim**: approximately 4 MiB

When the file exceeds the size cap, `trimHistoryFileIfTooLarge()` removes the oldest lines until the file shrinks to the target size. This rotation happens automatically during the flush cycle.

### Asynchronous Write Queue

The `flushToDisk` routine checks the file size, trims if necessary, then appends new JSON lines using `fs.appendFileSync`. This design ensures that tool calls are recorded without blocking the main execution thread.

## Cross-Platform Storage Paths

Because the log path derives from `os.homedir()`, the audit logging mechanism is **platform-agnostic**. The same code executes on all supported operating systems, with the OS determining the actual directory resolution.

| Platform | `os.homedir()` Resolution | Final Audit File Location |
|----------|---------------------------|---------------------------|
| **macOS** | `/Users/<username>` | `/Users/<username>/.claude-server-commander/tool-history.jsonl` |
| **Linux** | `/home/<username>` | `/home/<username>/.claude-server-commander/tool-history.jsonl` |
| **Windows** | `C:\Users\<username>` | `C:\Users\<username>\.claude-server-commander\tool-history.jsonl` |

## Secondary and Legacy Log Files

Beyond the primary JSONL audit store, DesktopCommanderMCP maintains additional logging infrastructure.

### Legacy Plain-Text Logger

The older `trackTools` helper in [`src/utils/trackTools.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/trackTools.ts) writes plain-text logs to a different directory structure:

```

~/.claude-server-commander-logs/fuzzy-search.log

```

This logger rotates files when they reach approximately **10 MiB**, compared to the 5 MiB cap used by the primary audit system.

### Specialized Loggers

Additional components like [`src/utils/fuzzySearchLogger.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/fuzzySearchLogger.ts) implement domain-specific logging under the same home-directory scheme. These files complement the main audit trail but use different rotation strategies and formats.

## Programmatic Access to Audit Logs

You can interact with the audit system directly through the `toolHistory` API.

### Retrieving Recent Calls

To fetch formatted history entries with timezone conversion:

```typescript
import { toolHistory } from './utils/toolHistory';

const recent = toolHistory.getRecentCallsFormatted({
  maxResults: 20,
  since: '2024-01-01T00:00:00Z',
});
console.log(recent);

```

### Cleanup and Shutdown

For graceful shutdown or test cleanup:

```typescript
await toolHistory.cleanup();   // Flushes pending writes and clears timers

```

### Accessing the File Path Directly

To locate the audit file programmatically:

```typescript
import { toolHistory } from './utils/toolHistory';
console.log('Audit file:', toolHistory.getStats().historyFile);

```

## Summary

- DesktopCommanderMCP stores **tool call logs** in `~/.claude-server-commander/tool-history.jsonl` using a JSONL format.
- The [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts) module provides the primary **audit logging** implementation with a 5 MiB size cap and 1,000-entry memory buffer.
- **Cross-platform compatibility** is achieved through `os.homedir()`, resulting in platform-specific paths on macOS (`/Users/...`), Linux (`/home/...`), and Windows (`C:\Users\...`).
- Legacy logging in [`src/utils/trackTools.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/trackTools.ts) uses plain-text format with 10 MiB rotation under `~/.claude-server-commander-logs/`.

## Frequently Asked Questions

### Where exactly is the tool call audit log stored on Windows?

On Windows, the audit log is stored at `C:\Users\<username>\.claude-server-commander\tool-history.jsonl`, where `<username>` is the current user's profile name. The path is constructed dynamically using Node.js's `os.homedir()` function, which resolves to the user's home directory regardless of Windows version.

### What is the maximum size of the audit log file before rotation?

The primary audit file caps at **5 MiB**, at which point the system trims oldest entries until the file reaches approximately **4 MiB**. This is implemented in the `trimHistoryFileIfTooLarge()` function within [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts). Secondary log files used by the legacy `trackTools` system rotate at **10 MiB** instead.

### How can I programmatically retrieve recent tool call history?

Import the `toolHistory` singleton from [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts) and call `getRecentCallsFormatted()`, passing optional parameters for `maxResults` and `since` timestamp. This returns the most recent entries with timestamps converted to the local timezone, formatted for display or further processing.

### Does DesktopCommanderMCP support custom audit log directories?

Currently, the audit log directory is hardcoded to `.claude-server-commander` within the user's home directory as defined by `os.homedir()`. The path is constructed in [`src/utils/toolHistory.ts`](https://github.com/wonderwhy-er/DesktopCommanderMCP/blob/main/src/utils/toolHistory.ts) without configuration options, meaning you cannot specify custom locations without modifying the source code. Direct file access is possible by reading the JSONL file directly from the resolved home directory path.