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

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	Core connection lifecycle, state machine implementation, and credential handling
src/OpenClaw.Shared/OpenClawGatewayClient.cs	Low-level WebSocket client for the operator role
src/OpenClaw.Shared/WindowsNodeClient.cs	Node-side protocol implementation including node.invoke and pairing logic
src/OpenClaw.Tray.WinUI/App.xaml.cs	Startup wiring that creates GatewayRegistry, CredentialResolver, and GatewayConnectionManager
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, you initiate connections using the IGatewayConnectionManager interface implemented in GatewayConnectionManager.cs:

// 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 file documents the pairing flow using ApplySetupCodeAsync to process setup codes:

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 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):

// 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, WindowsNodeClient.cs, and 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 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, while the actual protocol implementation resides in 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 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.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}