# Where to Find openclaw-windows-node Documentation: A Complete Guide to the docs/ Folder

> Find all openclaw-windows-node documentation in the repository's docs folder. Access comprehensive markdown guides on architecture, connection flows, and implementations.

- Repository: [openclaw/openclaw-windows-node](https://github.com/openclaw/openclaw-windows-node)
- Tags: how-to-guide
- Published: 2026-06-06

---

**All official openclaw-windows-node documentation is located in the top-level `docs/` folder of the repository**, which contains comprehensive markdown guides covering architecture, connection flows, and platform-specific implementation details.

The openclaw-windows-node repository ships with extensive documentation that serves as the primary source of truth for understanding the Windows node implementation. These files describe the three-layer architecture, gateway connection managers, and node capabilities while cross-referencing the exact source files where each feature is implemented.

## Documentation Structure in the Repository

The `docs/` folder at the repository root contains six authoritative markdown files. Each document targets a specific aspect of the system and includes inline references to source code locations.

### Core Architecture Documents

- **CONNECTION_ARCHITECTURE.md** – Details the three-layer design (`OpenClaw.Shared → OpenClaw.Connection → OpenClaw.Tray.WinUI`), the `IGatewayConnectionManager` API, and how the tray UI consumes the connection layer. It documents the gateway-client stack, state machine transitions, credential precedence rules, and lifecycle events.

- **WINDOWS_NODE_ARCHITECTURE.md** – Explains the roadmap for turning the tray app into a full Windows node, including the capability matrix (canvas, camera, screen, notifications) and the JSON protocol the node uses to communicate with the gateway.

- **MCP_MODE.md** – Describes how to run the local MCP server without a gateway, detailing the interaction of `EnableMcpServer` and `EnableNodeMode` flags and their impact on the tray application behavior.

- **ONBOARDING_WIZARD.md** – Walks through the first-run setup flow, QR-code handling via `SetupCodeDecoder`, and the process of converting a bootstrap token into a device token.

- **DATA_FLOW_ARCHITECTURE.md** – Provides diagrams and descriptions of end-to-end data movement between the tray, gateway, and node, covering how events, diagnostics, and payloads travel through the connection stack.

- **TEST_COVERAGE.md** – Lists the unit-test projects (`OpenClaw.Connection.Tests`, `OpenClaw.Tray.Tests`, etc.) and specifies what they validate within the connection layer and node capabilities.

## Key Implementation Files Referenced in Documentation

The documentation consistently references these source files to ground architectural concepts in actual implementations:

| File Path | Role |
|---|---|
| [`src/OpenClaw.Connection/GatewayConnectionManager.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Connection/GatewayConnectionManager.cs) | Core connection lifecycle, state machine implementation, and credential handling |
| [`src/OpenClaw.Shared/OpenClawGatewayClient.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Shared/OpenClawGatewayClient.cs) | Low-level WebSocket client for the operator role |
| [`src/OpenClaw.Shared/WindowsNodeClient.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Shared/WindowsNodeClient.cs) | Node-side protocol implementation including `node.invoke` and pairing logic |
| [`src/OpenClaw.Tray.WinUI/App.xaml.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Tray.WinUI/App.xaml.cs) | Startup wiring that creates `GatewayRegistry`, `CredentialResolver`, and `GatewayConnectionManager` |
| [`src/OpenClaw.SetupEngine/SetupCodeDecoder.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.SetupEngine/SetupCodeDecoder.cs) | Decodes QR codes and setup codes into URLs and bootstrap tokens |
| `tests/OpenClaw.Connection.Tests/` | Unit tests validating the connection state machine, credential precedence, and node pairing logic |

## Common Documentation Workflows

The documentation provides entry points for the most common development tasks, with code examples referencing the actual implementation files.

### Establishing a Gateway Connection

According to [`docs/CONNECTION_ARCHITECTURE.md`](https://github.com/openclaw/openclaw-windows-node/blob/main/docs/CONNECTION_ARCHITECTURE.md), you initiate connections using the `IGatewayConnectionManager` interface implemented in [`GatewayConnectionManager.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/GatewayConnectionManager.cs):

```csharp
// Create the manager (see docs/CONNECTION_ARCHITECTURE.md for wiring)
var connMgr = new GatewayConnectionManager(
    credentialResolver,            // ICredentialResolver
    clientFactory,                // IGatewayClientFactory
    registry,                     // GatewayRegistry
    logger);                      // IOpenClawLogger

// Connect to the active gateway (or specify an ID)
await connMgr.ConnectAsync();

```

### Handling QR Code Onboarding

The [`docs/ONBOARDING_WIZARD.md`](https://github.com/openclaw/openclaw-windows-node/blob/main/docs/ONBOARDING_WIZARD.md) file documents the pairing flow using `ApplySetupCodeAsync` to process setup codes:

```csharp
var result = await connMgr.ApplySetupCodeAsync("openclaw://gw.example.com?token=abc123");
if (result.Outcome == SetupCodeOutcome.Success)
{
    // The gateway record is now active and connection has been started.
}

```

This method is implemented in [`src/OpenClaw.Connection/GatewayConnectionManager.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Connection/GatewayConnectionManager.cs) and handles the transition from bootstrap token to active device token via the `SetupCodeDecoder`.

### Ensuring Node Connectivity

To activate node capabilities specifically, the documentation references `EnsureNodeConnectedAsync` (lines 979-1045 in [`GatewayConnectionManager.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/GatewayConnectionManager.cs)):

```csharp
// After the operator client is Connected, start the node role.
await connMgr.EnsureNodeConnectedAsync();

```

This method is essential when you need the Windows node capabilities (canvas, camera, notifications) rather than just the operator client connection.

## Summary

- **Primary Location**: All openclaw-windows-node documentation resides in the top-level `docs/` folder as markdown files.
- **Architectural Guides**: Six core documents cover connection architecture, Windows node capabilities, MCP mode, onboarding, data flow, and testing.
- **Source References**: Documentation links directly to implementation files like [`GatewayConnectionManager.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/GatewayConnectionManager.cs), [`WindowsNodeClient.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/WindowsNodeClient.cs), and [`SetupCodeDecoder.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/SetupCodeDecoder.cs).
- **Code Examples**: The docs contain runnable C# snippets showing how to use `IGatewayConnectionManager`, handle QR codes, and manage node connectivity.

## Frequently Asked Questions

### Where is the openclaw-windows-node documentation located?

All documentation is located in the `docs/` folder at the root of the openclaw/openclaw-windows-node repository. This folder contains markdown files covering architecture, connection flows, and testing strategies, with each file cross-referencing the specific source code files it describes.

### What does the Connection Architecture document cover?

The [`CONNECTION_ARCHITECTURE.md`](https://github.com/openclaw/openclaw-windows-node/blob/main/CONNECTION_ARCHITECTURE.md) file details the three-layer design (`OpenClaw.Shared → OpenClaw.Connection → OpenClaw.Tray.WinUI`), the `IGatewayConnectionManager` API, state machine transitions, and credential precedence rules. It serves as the primary reference for understanding how the tray UI consumes the connection layer and manages gateway lifecycles.

### How do I find implementation details for the Windows node capabilities?

Windows-specific capabilities (canvas, camera, screen, notifications) are documented in [`WINDOWS_NODE_ARCHITECTURE.md`](https://github.com/openclaw/openclaw-windows-node/blob/main/WINDOWS_NODE_ARCHITECTURE.md), while the actual protocol implementation resides in [`src/OpenClaw.Shared/WindowsNodeClient.cs`](https://github.com/openclaw/openclaw-windows-node/blob/main/src/OpenClaw.Shared/WindowsNodeClient.cs). The architecture document explains the JSON protocol used between the node and gateway, and the capability matrix defining which features are currently supported.

### Is there documentation for testing the connection layer?

Yes. The [`TEST_COVERAGE.md`](https://github.com/openclaw/openclaw-windows-node/blob/main/TEST_COVERAGE.md) file lists the unit-test projects, specifically `OpenClaw.Connection.Tests`, which validate the connection state machine, credential precedence logic, and node pairing workflows. These tests are located in the `tests/OpenClaw.Connection.Tests/` directory and correspond to the implementations described in the architecture documentation.