@decentnetwork/lan 0.1.198 → 0.1.200

package/README.md

@@ -15,7 +15,7 @@ Perfect for:
 ### Prerequisites
 
 - **Node.js 20+**
-- **Linux or macOS** (Windows support planned)
+- **Linux, macOS, or native 64-bit Windows** (x64 / ARM64)
 - **Carrier identity** (generate with `agentnet init`)
 
 ### Installation
@@ -224,8 +224,8 @@ agentnet openclaw diagnose --target <name>.agentnet
 
 ## Limitations (MVP v0.1)
 
-- Linux/macOS only (Windows in future)
-- TCP only (UDP planned in v0.2)
+- Native Windows uses Wintun and must run from an Administrator PowerShell
+- Kernel NAT/masquerade is Linux-only; the cross-platform CONNECT exit proxy does not need it
 - No remote desktop protocol support (TBD)
 - No video/media optimization (rely on Carrier relay)
 - Static IPAM (blockchain registry planned for v1.0)

package/bin/WINTUN-LICENSE.txt

@@ -0,0 +1,84 @@
+Prebuilt Binaries License
+-------------------------
+
+1. DEFINITIONS. "Software" means the precise contents of the "wintun.dll"
+   files that are included in the .zip file that contains this document as
+   downloaded from wintun.net/builds.
+
+2. LICENSE GRANT. WireGuard LLC grants to you a non-exclusive and
+   non-transferable right to use Software for lawful purposes under certain
+   obligations and limited rights as set forth in this agreement.
+
+3. RESTRICTIONS. Software is owned and copyrighted by WireGuard LLC. It is
+   licensed, not sold. Title to Software and all associated intellectual
+   property rights are retained by WireGuard. You must not:
+   a. reverse engineer, decompile, disassemble, extract from, or otherwise
+      modify the Software;
+   b. modify or create derivative work based upon Software in whole or in
+      parts, except insofar as only the API interfaces of the "wintun.h" file
+      distributed alongside the Software (the "Permitted API") are used;
+   c. remove any proprietary notices, labels, or copyrights from the Software;
+   d. resell, redistribute, lease, rent, transfer, sublicense, or otherwise
+      transfer rights of the Software without the prior written consent of
+      WireGuard LLC, except insofar as the Software is distributed alongside
+      other software that uses the Software only via the Permitted API;
+   e. use the name of WireGuard LLC, the WireGuard project, the Wintun
+      project, or the names of its contributors to endorse or promote products
+      derived from the Software without specific prior written consent.
+
+4. LIMITED WARRANTY. THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTY OF
+   ANY KIND. WIREGUARD LLC HEREBY EXCLUDES AND DISCLAIMS ALL IMPLIED OR
+   STATUTORY WARRANTIES, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS
+   FOR A PARTICULAR PURPOSE, QUALITY, NON-INFRINGEMENT, TITLE, RESULTS,
+   EFFORTS, OR QUIET ENJOYMENT. THERE IS NO WARRANTY THAT THE PRODUCT WILL BE
+   ERROR-FREE OR WILL FUNCTION WITHOUT INTERRUPTION. YOU ASSUME THE ENTIRE
+   RISK FOR THE RESULTS OBTAINED USING THE PRODUCT. TO THE EXTENT THAT
+   WIREGUARD LLC MAY NOT DISCLAIM ANY WARRANTY AS A MATTER OF APPLICABLE LAW,
+   THE SCOPE AND DURATION OF SUCH WARRANTY WILL BE THE MINIMUM PERMITTED UNDER
+   SUCH LAW. ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND
+   WARRANTIES, INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR
+   A PARTICULAR PURPOSE OR NON-INFRINGEMENT ARE DISCLAIMED, EXCEPT TO THE
+   EXTENT THAT THESE DISCLAIMERS ARE HELD TO BE LEGALLY INVALID.
+
+5. LIMITATION OF LIABILITY. To the extent not prohibited by law, in no event
+   WireGuard LLC or any third-party-developer will be liable for any lost
+   revenue, profit or data or for special, indirect, consequential, incidental
+   or punitive damages, however caused regardless of the theory of liability,
+   arising out of or related to the use of or inability to use Software, even
+   if WireGuard LLC has been advised of the possibility of such damages.
+   Solely you are responsible for determining the appropriateness of using
+   Software and accept full responsibility for all risks associated with its
+   exercise of rights under this agreement, including but not limited to the
+   risks and costs of program errors, compliance with applicable laws, damage
+   to or loss of data, programs or equipment, and unavailability or
+   interruption of operations. The foregoing limitations will apply even if
+   the above stated warranty fails of its essential purpose. You acknowledge,
+   that it is in the nature of software that software is complex and not
+   completely free of errors. In no event shall WireGuard LLC or any
+   third-party-developer be liable to you under any theory for any damages
+   suffered by you or any user of Software or for any special, incidental,
+   indirect, consequential or similar damages (including without limitation
+   damages for loss of business profits, business interruption, loss of
+   business information or any other pecuniary loss) arising out of the use or
+   inability to use Software, even if WireGuard LLC has been advised of the
+   possibility of such damages and regardless of the legal or quitable theory
+   (contract, tort, or otherwise) upon which the claim is based.
+
+6. TERMINATION. This agreement is affected until terminated. You may
+   terminate this agreement at any time. This agreement will terminate
+   immediately without notice from WireGuard LLC if you fail to comply with
+   the terms and conditions of this agreement. Upon termination, you must
+   delete Software and all copies of Software and cease all forms of
+   distribution of Software.
+
+7. SEVERABILITY. If any provision of this agreement is held to be
+   unenforceable, this agreement will remain in effect with the provision
+   omitted, unless omission would frustrate the intent of the parties, in
+   which case this agreement will immediately terminate.
+
+8. RESERVATION OF RIGHTS. All rights not expressly granted in this agreement
+   are reserved by WireGuard LLC. For example, WireGuard LLC reserves the
+   right at any time to cease development of Software, to alter distribution
+   details, features, specifications, capabilities, functions, licensing
+   terms, release dates, APIs, ABIs, general availability, or other
+   characteristics of the Software.

package/bin/WINTUN-SOURCE.json

@@ -0,0 +1,10 @@
+{
+  "version": "0.14.1",
+  "source": "https://www.wintun.net/builds/wintun-0.14.1.zip",
+  "sourceSha256": "07c256185d6ee3652e09fa55c0b673e2624b565e02c4b9091c79ca7d2f24ef51",
+  "files": {
+    "bin/windows-amd64/wintun.dll": "e5da8447dc2c320edc0fc52fa01885c103de8c118481f683643cacc3220dafce",
+    "bin/windows-arm64/wintun.dll": "f7ba89005544be9d85231a9e0d5f23b2d15b3311667e2dad0debd344918a3f80",
+    "bin/WINTUN-LICENSE.txt": "183adac21e7d96c508c8fd34d394b7b6708bc81564ad1bad61ab66143a008cd2"
+  }
+}

package/dist/cli/commands.d.ts

@@ -461,16 +461,21 @@ export declare function cmdDoraAutofriend(args: {
  *          doesn't pick up an empty /root/.agentnet.
  * macOS  → writes /Library/LaunchDaemons/com.decentlan.agentnet.plist,
  *          launchctl load (RunAtLoad + KeepAlive).
+ * Windows → writes a PowerShell launcher in the config directory and
+ *           registers an elevated SYSTEM startup task with schtasks.exe.
  *
- * Both surfaces stream stdout/stderr to /var/log/agentnet.log so a
- * single `tail -f /var/log/agentnet.log` works regardless of platform.
- * `--uninstall` reverses each respectively.
+ * Unix services stream stdout/stderr to the journal or
+ * /var/log/agentnet.log; Windows logs beside config.yaml.
+ * `--uninstall` reverses each platform's installation.
  *
- * Requires root (writes to /etc or /Library). On Linux the resolved
- * unit will run as User=root; on macOS the LaunchDaemon already runs
- * as root. The CLI complains loudly with the missing-sudo hint if
- * the writes fail with EACCES.
- */
+ * Requires root on Unix or an Administrator PowerShell on Windows.
+ */
+export declare function windowsServiceLauncherScript(args: {
+    nodeBin: string;
+    cliEntry: string;
+    configDir: string;
+    logPath: string;
+}): string;
 export declare function cmdServiceInstall(args: {
     uninstall?: boolean;
     configDir?: string;
@@ -490,7 +495,7 @@ export declare function cmdServiceStatus(_args: {
  * no sudo — use that for picking up an upgrade; use this when the service
  * itself is wedged/stopped and you want launchd/systemd to bring it back.
  */
-export declare function cmdServiceRestart(_args: {
+export declare function cmdServiceRestart(args: {
     configDir?: string;
 }): Promise<void>;
 /**

package/dist/cli/commands.js

@@ -909,7 +909,7 @@ export async function cmdProxyEnable(args) {
     };
     await ConfigLoader.save(config, configPath);
     console.log(`Proxy enabled on port ${config.proxy.port}.`);
-    console.log(`Listener will bind to ${config.network.ip}:${config.proxy.port} on next 'agentnet up'.`);
+    console.log(`Listener will bind to this node's runtime AgentNet IP on next 'agentnet up'.`);
     if ((config.proxy.allowHosts ?? []).length === 0) {
         console.log(`(No host allowlist set — any host will be accepted as a CONNECT target.)`);
         console.log(`To restrict: agentnet proxy allow-host '*.binance.com'`);
@@ -947,7 +947,7 @@ export async function cmdProxyStatus(args) {
         return;
     }
     console.log("Proxy: enabled");
-    console.log(`  listen:        ${config.network.ip}:${proxy.port}`);
+    console.log(`  listen:        <runtime AgentNet IP>:${proxy.port}`);
     console.log(`  protocol:      HTTP CONNECT`);
     const allowHosts = proxy.allowHosts ?? [];
     if (allowHosts.length === 0) {
@@ -2100,16 +2100,27 @@ export async function cmdDoraAutofriend(args) {
  *          doesn't pick up an empty /root/.agentnet.
  * macOS  → writes /Library/LaunchDaemons/com.decentlan.agentnet.plist,
  *          launchctl load (RunAtLoad + KeepAlive).
+ * Windows → writes a PowerShell launcher in the config directory and
+ *           registers an elevated SYSTEM startup task with schtasks.exe.
  *
- * Both surfaces stream stdout/stderr to /var/log/agentnet.log so a
- * single `tail -f /var/log/agentnet.log` works regardless of platform.
- * `--uninstall` reverses each respectively.
+ * Unix services stream stdout/stderr to the journal or
+ * /var/log/agentnet.log; Windows logs beside config.yaml.
+ * `--uninstall` reverses each platform's installation.
  *
- * Requires root (writes to /etc or /Library). On Linux the resolved
- * unit will run as User=root; on macOS the LaunchDaemon already runs
- * as root. The CLI complains loudly with the missing-sudo hint if
- * the writes fail with EACCES.
+ * Requires root on Unix or an Administrator PowerShell on Windows.
  */
+export function windowsServiceLauncherScript(args) {
+    const psq = (value) => `'${value.replace(/'/g, "''")}'`;
+    return `$ErrorActionPreference = 'Continue'
+$env:AGENTNET_SERVICE_WRAPPER = '1'
+while ($true) {
+  & ${psq(args.nodeBin)} ${psq(args.cliEntry)} up --real-tun --config-dir ${psq(args.configDir)} *>> ${psq(args.logPath)}
+  $code = $LASTEXITCODE
+  "$(Get-Date -Format o) agentnet exited with code $code; restarting in 5 seconds" | Out-File -FilePath ${psq(args.logPath)} -Append -Encoding utf8
+  Start-Sleep -Seconds 5
+}
+`;
+}
 export async function cmdServiceInstall(args) {
     // Detect sudo's $HOME=/root trap. When `service install` is run via
     // sudo and no --config-dir is provided, derive the home dir from
@@ -2150,6 +2161,46 @@ export async function cmdServiceInstall(args) {
     const nodeBin = process.execPath;
     const nodeDir = dirname(nodeBin);
     const servicePath = `${nodeDir}:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin`;
+    if (process.platform === "win32") {
+        const taskName = "Decent AgentNet";
+        const scriptPath = resolve(dir, "agentnet-service.ps1");
+        const logPath = resolve(dir, "agentnet-service.log");
+        if (args.uninstall) {
+            spawnSync("schtasks.exe", ["/End", "/TN", taskName], { stdio: "ignore" });
+            const removed = spawnSync("schtasks.exe", ["/Delete", "/F", "/TN", taskName], { stdio: "inherit" });
+            try {
+                const { unlinkSync, existsSync } = await import("fs");
+                if (existsSync(scriptPath))
+                    unlinkSync(scriptPath);
+            }
+            catch {
+                // Task removal is the important part; script cleanup is best effort.
+            }
+            if ((removed.status ?? 1) !== 0)
+                throw new Error(`Could not remove Windows scheduled task '${taskName}'`);
+            console.log(`Removed Windows startup task '${taskName}'.`);
+            return;
+        }
+        const cliEntry = resolve(dirname(fileURLToPath(import.meta.url)), "index.js");
+        const psq = (value) => `'${value.replace(/'/g, "''")}'`;
+        const script = windowsServiceLauncherScript({ nodeBin, cliEntry, configDir: dir, logPath });
+        const fs = await import("fs/promises");
+        await fs.mkdir(dir, { recursive: true });
+        await fs.writeFile(scriptPath, script, "utf-8");
+        const taskCommand = `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -File "${scriptPath}"`;
+        const created = spawnSync("schtasks.exe", [
+            "/Create", "/F", "/TN", taskName, "/SC", "ONSTART", "/RU", "SYSTEM", "/RL", "HIGHEST", "/TR", taskCommand,
+        ], { stdio: "inherit" });
+        if ((created.status ?? 1) !== 0) {
+            throw new Error("Could not create the AgentNet Windows startup task. Open PowerShell as Administrator and retry.");
+        }
+        const started = spawnSync("schtasks.exe", ["/Run", "/TN", taskName], { stdio: "inherit" });
+        if ((started.status ?? 1) !== 0)
+            throw new Error(`Created '${taskName}' but could not start it`);
+        console.log(`Installed and started Windows startup task '${taskName}'.`);
+        console.log(`Logs: Get-Content -Wait ${psq(logPath)}`);
+        return;
+    }
     if (process.platform === "linux") {
         const unitPath = "/etc/systemd/system/agentnet.service";
         if (args.uninstall) {
@@ -2303,6 +2354,15 @@ export async function cmdServiceStatus(_args) {
         process.stdout.write(r.stdout || "");
         return;
     }
+    if (process.platform === "win32") {
+        const r = spawnSync("schtasks.exe", ["/Query", "/TN", "Decent AgentNet", "/V", "/FO", "LIST"], { encoding: "utf-8" });
+        if ((r.status ?? 0) !== 0) {
+            console.log("Not installed. Open PowerShell as Administrator and run 'agentnet service install'.");
+            return;
+        }
+        process.stdout.write(r.stdout || "");
+        return;
+    }
     console.log(`'service status' isn't wired up for ${process.platform}.`);
 }
 /**
@@ -2312,7 +2372,7 @@ export async function cmdServiceStatus(_args) {
  * no sudo — use that for picking up an upgrade; use this when the service
  * itself is wedged/stopped and you want launchd/systemd to bring it back.
  */
-export async function cmdServiceRestart(_args) {
+export async function cmdServiceRestart(args) {
     const { spawnSync } = await import("child_process");
     if (process.platform === "linux") {
         const r = spawnSync("systemctl", ["restart", "agentnet"], { stdio: "inherit" });
@@ -2344,6 +2404,34 @@ export async function cmdServiceRestart(_args) {
         console.log(`Restarted ${label}. Logs: tail -f /var/log/agentnet.log`);
         return;
     }
+    if (process.platform === "win32") {
+        // Prefer the daemon's graceful restart path: it closes Carrier sessions,
+        // stdin-signals the Wintun helper, releases IPC/routes, and then exits.
+        // The scheduled-task wrapper notices the exit and relaunches it. A raw
+        // schtasks /End is only the recovery fallback when IPC is unavailable.
+        try {
+            const dir = args.configDir || ConfigLoader.defaultConfigDir();
+            const config = await ConfigLoader.load(resolve(dir, "config.yaml"));
+            if (daemonPid(config) !== null) {
+                const res = await ipcCall(config, { op: "self-restart" });
+                if (res.ok) {
+                    console.log(`Graceful restart requested for '${"Decent AgentNet"}'.`);
+                    return;
+                }
+            }
+        }
+        catch {
+            // No reachable daemon: fall through and recover the scheduled task.
+        }
+        const taskName = "Decent AgentNet";
+        spawnSync("schtasks.exe", ["/End", "/TN", taskName], { stdio: "ignore" });
+        const run = spawnSync("schtasks.exe", ["/Run", "/TN", taskName], { stdio: "inherit" });
+        if ((run.status ?? 1) !== 0) {
+            throw new Error(`Could not restart '${taskName}'. Open PowerShell as Administrator and run 'agentnet service install'.`);
+        }
+        console.log(`Restarted '${taskName}'.`);
+        return;
+    }
     throw new Error(`'service restart' isn't wired up for ${process.platform}.`);
 }
 /**

package/dist/cli/index.js

@@ -116,10 +116,10 @@ async function main() {
         .demandCommand(1, "Specify a dns subcommand (run 'agentnet dns --help')"), () => {
         // parent handler — never invoked because demandCommand
     })
-        // Persistent system service — wraps systemctl (Linux) and
-        // launchctl (macOS) so a new operator runs ONE command to install
+        // Persistent system service — wraps systemctl (Linux), launchctl
+        // (macOS), or a highest-privilege startup task (Windows) so a new operator runs ONE command to install
         // + start + persist instead of hand-writing a unit/plist.
-        .command("service", "Install/uninstall/inspect the daemon as a system service (systemd on Linux, launchd on macOS)", (y) => y
+        .command("service", "Install/uninstall/inspect the daemon as a system service/startup task", (y) => y
         .command("install", "Write the unit/plist, enable + start (needs sudo)", (yy) => yy
         .option("uninstall", { type: "boolean", default: false, describe: "Reverse the install" })
         .option("config-dir", { type: "string" }), async (argv) => {

package/dist/console/console.js

@@ -881,6 +881,16 @@ var ConfigLoader = class {
   }
 };
 
+// src/daemon/ipc.ts
+import { createHash } from "crypto";
+function ipcSocketPath(dataDir, platform = process.platform) {
+  if (platform === "win32") {
+    const id = createHash("sha256").update(dataDir.toLowerCase()).digest("hex").slice(0, 16);
+    return `\\\\.\\pipe\\agentnet-${id}`;
+  }
+  return `${dataDir.replace(/\/+$/, "")}/daemon.sock`;
+}
+
 // src/console/data.ts
 function fileSize(n) {
   if (!n || n < 0) return "0 B";
@@ -910,7 +920,7 @@ var DaemonClient = class _DaemonClient {
     const dir = configDir ?? resolve2(homedir3(), ".agentnet");
     const config = await ConfigLoader.load(resolve2(dir, "config.yaml"));
     const dataDir = (config.carrier.dataDir || resolve2(dir, "carrier")).replace(/\/+$/, "");
-    return new _DaemonClient(`${dataDir}/daemon.sock`);
+    return new _DaemonClient(ipcSocketPath(dataDir));
   }
   call(req, timeoutMs = 5e3) {
     return new Promise((res, rej) => {

package/dist/daemon/ipc.d.ts

@@ -1,5 +1,5 @@
 /**
- * IPC server — Unix-domain-socket bridge so the CLI can drive the
+ * IPC server — local-socket bridge so the CLI can drive the
  * running daemon's Carrier identity without spawning a second Peer.
  *
  * Why: the daemon owns the keypair while it's up. A `node dist/cli
@@ -15,11 +15,11 @@
  * response, then both sides close. Keeping it one-shot avoids
  * dealing with multiplexing or reconnect logic for v0.1.
  *
- * Socket location: <dataDir>/daemon.sock — same directory as the
- * pidfile. Permissions are loosened to 0666 so the user's CLI can
- * connect when the daemon ran via sudo (otherwise the socket is
- * root-owned). That's acceptable for a single-user box; multi-user
- * hardening can come later via SO_PEERCRED filtering.
+ * Socket location: <dataDir>/daemon.sock on Unix; a stable named pipe
+ * derived from dataDir on Windows. Unix permissions are loosened to 0666
+ * so the user's CLI can connect when the daemon ran via sudo (otherwise
+ * the socket is root-owned). That's acceptable for a single-user box;
+ * multi-user hardening can come later via peer-credential filtering.
  */
 export interface IpcHandlers {
     /** Send a friend-request via the daemon's Carrier peer. Returns
@@ -63,7 +63,7 @@ export interface IpcHandlers {
     /** Sign `text` (UTF-8) with this node's Carrier identity key and return the
      *  detached signature (hex) plus our userid. Backs "Sign in with Decent":
      *  the UI server's local-only /connect flow calls this on Approve. Reachable
-     *  ONLY over this Unix socket — never exposed on a TCP interface. */
+     *  ONLY over this local socket/pipe — never exposed on a TCP interface. */
     sign: (text: string) => Promise<{
         sig: string;
         userid: string;
@@ -147,9 +147,10 @@ export declare class IpcServer {
     constructor(socketPath: string, handlers: IpcHandlers);
     start(): Promise<void>;
     stop(): Promise<void>;
+    private isWindowsNamedPipe;
     private handleConnection;
     private dispatch;
 }
 /** Derive the socket path that pairs with a given carrier data dir.
  *  Kept as a one-liner helper so daemon and client agree. */
-export declare function ipcSocketPath(dataDir: string): string;
+export declare function ipcSocketPath(dataDir: string, platform?: NodeJS.Platform): string;

package/dist/daemon/ipc.js

@@ -1,5 +1,5 @@
 /**
- * IPC server — Unix-domain-socket bridge so the CLI can drive the
+ * IPC server — local-socket bridge so the CLI can drive the
  * running daemon's Carrier identity without spawning a second Peer.
  *
  * Why: the daemon owns the keypair while it's up. A `node dist/cli
@@ -15,14 +15,15 @@
  * response, then both sides close. Keeping it one-shot avoids
  * dealing with multiplexing or reconnect logic for v0.1.
  *
- * Socket location: <dataDir>/daemon.sock — same directory as the
- * pidfile. Permissions are loosened to 0666 so the user's CLI can
- * connect when the daemon ran via sudo (otherwise the socket is
- * root-owned). That's acceptable for a single-user box; multi-user
- * hardening can come later via SO_PEERCRED filtering.
+ * Socket location: <dataDir>/daemon.sock on Unix; a stable named pipe
+ * derived from dataDir on Windows. Unix permissions are loosened to 0666
+ * so the user's CLI can connect when the daemon ran via sudo (otherwise
+ * the socket is root-owned). That's acceptable for a single-user box;
+ * multi-user hardening can come later via peer-credential filtering.
  */
 import { createServer } from "net";
 import { chmodSync, existsSync, unlinkSync } from "fs";
+import { createHash } from "crypto";
 import { Logger } from "../utils/logger.js";
 export class IpcServer {
     socketPath;
@@ -38,7 +39,7 @@ export class IpcServer {
         // A stale socket from a previously-crashed daemon will make
         // listen() throw EADDRINUSE — unlink it first. Pidfile-guard
         // already ensures no LIVE daemon is running, so deletion is safe.
-        if (existsSync(this.socketPath)) {
+        if (!this.isWindowsNamedPipe() && existsSync(this.socketPath)) {
             try {
                 unlinkSync(this.socketPath);
             }
@@ -57,11 +58,13 @@ export class IpcServer {
         // 0666 so non-root CLI can reach a sudo-launched daemon. SO_PEERCRED
         // / SO_PEEREID would be a tighter filter, but for v0.1 the trust
         // boundary is "anyone with shell access to this box".
-        try {
-            chmodSync(this.socketPath, 0o666);
-        }
-        catch (err) {
-            this.logger.warn(`chmod ${this.socketPath}: ${err}`);
+        if (!this.isWindowsNamedPipe()) {
+            try {
+                chmodSync(this.socketPath, 0o666);
+            }
+            catch (err) {
+                this.logger.warn(`chmod ${this.socketPath}: ${err}`);
+            }
         }
         this.logger.info(`Listening on ${this.socketPath}`);
     }
@@ -72,14 +75,19 @@ export class IpcServer {
             this.server.close(() => resolve());
         });
         this.server = undefined;
-        try {
-            if (existsSync(this.socketPath))
-                unlinkSync(this.socketPath);
-        }
-        catch {
-            // best-effort
+        if (!this.isWindowsNamedPipe()) {
+            try {
+                if (existsSync(this.socketPath))
+                    unlinkSync(this.socketPath);
+            }
+            catch {
+                // best-effort
+            }
         }
     }
+    isWindowsNamedPipe() {
+        return this.socketPath.startsWith("\\\\.\\pipe\\");
+    }
     handleConnection(sock) {
         let buf = "";
         let handled = false;
@@ -266,7 +274,13 @@ export class IpcServer {
 }
 /** Derive the socket path that pairs with a given carrier data dir.
  *  Kept as a one-liner helper so daemon and client agree. */
-export function ipcSocketPath(dataDir) {
+export function ipcSocketPath(dataDir, platform = process.platform) {
+    if (platform === "win32") {
+        // Named pipes are the Windows equivalent of Unix-domain sockets. Hash the
+        // configured data directory so multiple AgentNet profiles do not collide.
+        const id = createHash("sha256").update(dataDir.toLowerCase()).digest("hex").slice(0, 16);
+        return `\\\\.\\pipe\\agentnet-${id}`;
+    }
     // Node's net.listen on Unix sockets supports paths up to ~104 bytes
     // on macOS; <dataDir>/daemon.sock fits comfortably for sane homedirs.
     return `${dataDir.replace(/\/+$/, "")}/daemon.sock`;

package/dist/daemon/server.js

@@ -690,17 +690,34 @@ export class DaemonServer {
                                 this.logger.error(`Self-restart cleanup failed: ${err instanceof Error ? err.message : err}`);
                             }
                             try {
-                                // sh -c so we can shell-quote argv safely and use sleep.
-                                // Node's detached flag reparents the relauncher to PID 1.
-                                // At this point stop() has released IPC, TUN and the pidfile;
-                                // the extra delay also lets relay writes flush remotely.
-                                const cmd = `sleep 1 && exec ${shellQuote([node, ...argv])}`;
-                                const child = spawn("sh", ["-c", cmd], {
-                                    detached: true,
-                                    stdio: "ignore",
-                                    env: process.env,
-                                });
-                                child.unref();
+                                if (process.platform === "win32") {
+                                    // A scheduled-task installation has a PowerShell supervisor
+                                    // that relaunches us after exit; spawning here as well would
+                                    // create two daemons sharing one Carrier identity. Foreground
+                                    // Windows runs still need a detached replacement.
+                                    if (process.env.AGENTNET_SERVICE_WRAPPER !== "1") {
+                                        const child = spawn(node, argv, {
+                                            detached: true,
+                                            stdio: "ignore",
+                                            env: process.env,
+                                            windowsHide: true,
+                                        });
+                                        child.unref();
+                                    }
+                                }
+                                else {
+                                    // sh -c so we can shell-quote argv safely and use sleep.
+                                    // Node's detached flag reparents the relauncher to PID 1.
+                                    // At this point stop() has released IPC, TUN and the pidfile;
+                                    // the extra delay also lets relay writes flush remotely.
+                                    const cmd = `sleep 1 && exec ${shellQuote([node, ...argv])}`;
+                                    const child = spawn("sh", ["-c", cmd], {
+                                        detached: true,
+                                        stdio: "ignore",
+                                        env: process.env,
+                                    });
+                                    child.unref();
+                                }
                             }
                             catch (err) {
                                 this.logger.error(`Self-restart spawn failed: ${err instanceof Error ? err.message : err}`);
@@ -1151,7 +1168,7 @@ export class DaemonServer {
                         else if (this.config.proxy.egress) {
                             this.logger.warn(`Proxy egress=${this.config.proxy.egress} requested but no physical NIC address found; using OS default egress`);
                         }
-                        this.connectProxy = new ConnectProxy({
+                        const proxyOptions = {
                             bindIp: tunIp,
                             port: this.config.proxy.port,
                             allowHosts: this.config.proxy.allowHosts ?? [],
@@ -1174,8 +1191,35 @@ export class DaemonServer {
                                     this.auditLog.logProxyClose({ srcIp: src, srcName, target, bytesTransferred });
                                 }
                                 : undefined,
-                        });
-                        await this.connectProxy.start();
+                        };
+                        // Windows reports New-NetIPAddress success slightly before Winsock
+                        // accepts bind() on that address. A one-shot start therefore races
+                        // with Wintun configuration and fails EADDRNOTAVAIL even though the
+                        // address becomes usable moments later. Retry only that transient
+                        // error; EADDRINUSE and policy/config errors still fail fast.
+                        const maxAttempts = process.platform === "win32" ? 40 : 1;
+                        let bindError;
+                        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+                            const candidate = new ConnectProxy(proxyOptions);
+                            try {
+                                await candidate.start();
+                                this.connectProxy = candidate;
+                                bindError = undefined;
+                                break;
+                            }
+                            catch (err) {
+                                bindError = err;
+                                const code = err.code;
+                                if (code !== "EADDRNOTAVAIL" || attempt === maxAttempts)
+                                    break;
+                                if (attempt === 1 || attempt % 10 === 0) {
+                                    this.logger.warn(`Proxy address ${tunIp} not bindable yet; retrying (${attempt}/${maxAttempts})`);
+                                }
+                                await new Promise((resolveRetry) => setTimeout(resolveRetry, 250));
+                            }
+                        }
+                        if (!this.connectProxy)
+                            throw bindError;
                         this.logger.info(`Proxy listening on ${tunIp}:${this.config.proxy.port}`);
                     }
                     catch (err) {

package/dist/tun/route-manager.d.ts

@@ -1,13 +1,20 @@
 /**
  * TUN device + route management.
- * Linux uses `ip` (iproute2). macOS uses `ifconfig` + `route`.
+ * Linux uses `ip` (iproute2), macOS uses `ifconfig` + `route`, and
+ * Windows uses the built-in NetTCPIP PowerShell cmdlets.
  */
 import type { TunDeviceConfig } from "./types.js";
+export type RoutePlatform = "linux" | "darwin" | "win32";
+export interface RouteManagerOptions {
+    platform?: RoutePlatform;
+    commandRunner?: (command: string) => string;
+}
 export declare class RouteManager {
     private logger;
     private createdInterface;
     private platform;
-    constructor();
+    private commandRunner;
+    constructor(opts?: RouteManagerOptions);
     /**
      * Create and configure TUN interface (Linux only — on macOS the helper
      * binary creates the utun device implicitly).
@@ -18,6 +25,7 @@ export declare class RouteManager {
      * `name` here should be the ACTUAL device name (e.g. utun12 on macOS).
      */
     configureTun(config: TunDeviceConfig): Promise<void>;
+    private configureTunWindows;
     private configureTunLinux;
     private configureTunDarwin;
     /**
@@ -43,6 +51,8 @@ export declare class RouteManager {
     setupMasquerade(subnet: string, outInterface: string, tunInterface: string): Promise<void>;
     cleanupMasquerade(subnet: string, outInterface: string, tunInterface: string): Promise<void>;
     private exec;
+    private powerShell;
+    private powerShellQuote;
     /**
      * Convert "10.86.0.0/16" -> 16
      */

package/dist/tun/route-manager.js

@@ -1,6 +1,7 @@
 /**
  * TUN device + route management.
- * Linux uses `ip` (iproute2). macOS uses `ifconfig` + `route`.
+ * Linux uses `ip` (iproute2), macOS uses `ifconfig` + `route`, and
+ * Windows uses the built-in NetTCPIP PowerShell cmdlets.
  */
 import { execSync } from "child_process";
 import { Logger } from "../utils/logger.js";
@@ -8,22 +9,23 @@ export class RouteManager {
     logger;
     createdInterface = null;
     platform;
-    constructor() {
+    commandRunner;
+    constructor(opts = {}) {
         this.logger = new Logger({ prefix: "RouteManager" });
-        if (process.platform === "darwin") {
-            this.platform = "darwin";
-        }
-        else {
-            this.platform = "linux";
+        const detected = opts.platform ?? process.platform;
+        if (detected !== "linux" && detected !== "darwin" && detected !== "win32") {
+            throw new Error(`Unsupported route platform: ${detected}`);
         }
+        this.platform = detected;
+        this.commandRunner = opts.commandRunner ?? ((command) => execSync(command, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }));
     }
     /**
      * Create and configure TUN interface (Linux only — on macOS the helper
      * binary creates the utun device implicitly).
      */
     async createTun(config) {
-        if (this.platform === "darwin") {
-            // utun is auto-created by the helper; just configure
+        if (this.platform === "darwin" || this.platform === "win32") {
+            // utun/Wintun is auto-created by the helper; just configure.
             await this.configureTun(config);
             return;
         }
@@ -48,8 +50,34 @@ export class RouteManager {
         if (this.platform === "darwin") {
             return this.configureTunDarwin(config);
         }
+        if (this.platform === "win32") {
+            return this.configureTunWindows(config);
+        }
         return this.configureTunLinux(config);
     }
+    async configureTunWindows(config) {
+        const { name, ip, subnet } = config;
+        const mtu = config.mtu ?? 900;
+        const alias = this.powerShellQuote(name);
+        const address = this.powerShellQuote(ip);
+        const destination = this.powerShellQuote(subnet);
+        // Use a /32 local address and add the AgentNet /16 explicitly. This mirrors
+        // the macOS point-to-point setup and avoids Windows creating a competing
+        // connected /16 route with an arbitrary metric.
+        this.powerShell([
+            "$ErrorActionPreference='Stop'",
+            `Enable-NetAdapter -Name ${alias} -Confirm:$false -ErrorAction SilentlyContinue`,
+            `Get-NetIPAddress -InterfaceAlias ${alias} -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { $_.IPAddress -like '10.86.*' } | Remove-NetIPAddress -Confirm:$false -ErrorAction SilentlyContinue`,
+            `Get-NetRoute -InterfaceAlias ${alias} -DestinationPrefix ${destination} -ErrorAction SilentlyContinue | Remove-NetRoute -Confirm:$false -ErrorAction SilentlyContinue`,
+            `New-NetIPAddress -InterfaceAlias ${alias} -IPAddress ${address} -PrefixLength 32 -AddressFamily IPv4 -PolicyStore ActiveStore | Out-Null`,
+            `Set-NetIPInterface -InterfaceAlias ${alias} -AddressFamily IPv4 -NlMtuBytes ${mtu}`,
+            `New-NetRoute -DestinationPrefix ${destination} -InterfaceAlias ${alias} -NextHop 0.0.0.0 -RouteMetric 1 -PolicyStore ActiveStore | Out-Null`,
+            `Get-NetFirewallRule -Name 'DecentAgentNet-Inbound' -ErrorAction SilentlyContinue | Remove-NetFirewallRule -ErrorAction SilentlyContinue`,
+            `New-NetFirewallRule -Name 'DecentAgentNet-Inbound' -DisplayName 'Decent AgentNet virtual network' -Direction Inbound -Action Allow -InterfaceAlias ${alias} -Profile Any | Out-Null`,
+        ].join("; "));
+        this.createdInterface = name;
+        this.logger.info(`Assigned ${ip}/32 to ${name}, route ${subnet}, mtu=${mtu} (Windows)`);
+    }
     async configureTunLinux(config) {
         const { name, ip, subnet } = config;
         const mtu = config.mtu ?? 900;
@@ -162,6 +190,13 @@ export class RouteManager {
      * Remove TUN interface (Linux only — on macOS utun goes away when helper exits).
      */
     async removeTun(name) {
+        if (this.platform === "win32") {
+            // Wintun adapters are intentionally persistent and reused by name. The
+            // helper ending its session is enough; cleanup() removes IP/routes.
+            this.logger.debug(`Windows Wintun adapter ${name} retained for reuse`);
+            this.createdInterface = null;
+            return;
+        }
         if (this.platform === "darwin") {
             // utun is auto-destroyed when the helper subprocess exits
             this.logger.debug(`macOS utun ${name} cleaned up by helper exit`);
@@ -221,6 +256,21 @@ export class RouteManager {
                 // utun device cleanup is handled when helper exits
                 return;
             }
+            if (this.platform === "win32") {
+                const alias = this.powerShellQuote(name);
+                const destination = this.powerShellQuote(subnet);
+                const removeIp = ip
+                    ? `Get-NetIPAddress -InterfaceAlias ${alias} -IPAddress ${this.powerShellQuote(ip)} -AddressFamily IPv4 -ErrorAction SilentlyContinue | Remove-NetIPAddress -Confirm:$false -ErrorAction SilentlyContinue`
+                    : `Get-NetIPAddress -InterfaceAlias ${alias} -AddressFamily IPv4 -ErrorAction SilentlyContinue | Where-Object { $_.IPAddress -like '10.86.*' } | Remove-NetIPAddress -Confirm:$false -ErrorAction SilentlyContinue`;
+                this.powerShell([
+                    "$ErrorActionPreference='SilentlyContinue'",
+                    `Get-NetRoute -InterfaceAlias ${alias} -DestinationPrefix ${destination} -ErrorAction SilentlyContinue | Remove-NetRoute -Confirm:$false -ErrorAction SilentlyContinue`,
+                    removeIp,
+                    `Get-NetFirewallRule -Name 'DecentAgentNet-Inbound' -ErrorAction SilentlyContinue | Remove-NetFirewallRule -ErrorAction SilentlyContinue`,
+                ].join("; "));
+                this.createdInterface = null;
+                return;
+            }
             try {
                 this.exec(`ip route del ${subnet} dev ${name}`);
             }
@@ -242,6 +292,10 @@ export class RouteManager {
      * Enable IP forwarding (Linux only)
      */
     async enableIpForwarding() {
+        if (this.platform === "win32") {
+            this.logger.warn("Kernel IP forwarding/NAT is not enabled on Windows; the AgentNet CONNECT exit proxy does not require it");
+            return;
+        }
         if (this.platform === "darwin") {
             try {
                 this.exec("sysctl -w net.inet.ip.forwarding=1");
@@ -264,7 +318,10 @@ export class RouteManager {
     }
     async disableIpForwarding() {
         try {
-            if (this.platform === "darwin") {
+            if (this.platform === "win32") {
+                return;
+            }
+            else if (this.platform === "darwin") {
                 this.exec("sysctl -w net.inet.ip.forwarding=0");
             }
             else {
@@ -281,8 +338,8 @@ export class RouteManager {
      * Not implemented on macOS in MVP.
      */
     async setupMasquerade(subnet, outInterface, tunInterface) {
-        if (this.platform === "darwin") {
-            this.logger.warn("Masquerade not implemented on macOS in MVP");
+        if (this.platform === "darwin" || this.platform === "win32") {
+            this.logger.warn(`Masquerade not implemented on ${this.platform} in MVP`);
             return;
         }
         this.exec(`iptables -t nat -A POSTROUTING -o ${outInterface} -j MASQUERADE`);
@@ -291,7 +348,7 @@ export class RouteManager {
         this.logger.info(`Masquerade setup for ${subnet} (${tunInterface} -> ${outInterface})`);
     }
     async cleanupMasquerade(subnet, outInterface, tunInterface) {
-        if (this.platform === "darwin")
+        if (this.platform === "darwin" || this.platform === "win32")
             return;
         for (const cmd of [
             `iptables -t nat -D POSTROUTING -o ${outInterface} -j MASQUERADE`,
@@ -310,13 +367,22 @@ export class RouteManager {
     exec(command) {
         this.logger.debug(`Executing: ${command}`);
         try {
-            return execSync(command, { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] });
+            return this.commandRunner(command);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             throw new Error(`Command failed: ${command}\n${message}`);
         }
     }
+    powerShell(script) {
+        // -EncodedCommand is UTF-16LE and avoids cmd.exe quoting/injection hazards
+        // from interface aliases or Windows paths.
+        const encoded = Buffer.from(script, "utf16le").toString("base64");
+        return this.exec(`powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -EncodedCommand ${encoded}`);
+    }
+    powerShellQuote(value) {
+        return `'${value.replace(/'/g, "''")}'`;
+    }
     /**
      * Convert "10.86.0.0/16" -> 16
      */

package/dist/tun/tun-device.d.ts

@@ -14,6 +14,10 @@ export interface TunDeviceOptions {
     mockMode?: boolean;
     helperPath?: string;
 }
+/** Relative helper path inside the package's bin/ directory. Windows keeps
+ * each architecture in its own directory because the matching driver DLL must
+ * be named exactly `wintun.dll` beside the executable. */
+export declare function helperBinaryRelativePath(platform: NodeJS.Platform, arch: string): string | null;
 export declare class TunDevice extends EventEmitter {
     private config;
     private logger;

package/dist/tun/tun-device.js

@@ -13,6 +13,24 @@ import { resolve, dirname } from "path";
 import { existsSync } from "fs";
 import { fileURLToPath } from "url";
 import { Logger } from "../utils/logger.js";
+/** Relative helper path inside the package's bin/ directory. Windows keeps
+ * each architecture in its own directory because the matching driver DLL must
+ * be named exactly `wintun.dll` beside the executable. */
+export function helperBinaryRelativePath(platform, arch) {
+    if (platform === "linux" && arch === "x64")
+        return "tun-helper-linux-amd64";
+    if (platform === "linux" && arch === "arm64")
+        return "tun-helper-linux-arm64";
+    if (platform === "darwin" && arch === "x64")
+        return "tun-helper-darwin-amd64";
+    if (platform === "darwin" && arch === "arm64")
+        return "tun-helper-darwin-arm64";
+    if (platform === "win32" && arch === "x64")
+        return "windows-amd64/tun-helper-windows-amd64.exe";
+    if (platform === "win32" && arch === "arm64")
+        return "windows-arm64/tun-helper-windows-arm64.exe";
+    return null;
+}
 export class TunDevice extends EventEmitter {
     config;
     logger;
@@ -81,7 +99,19 @@ export class TunDevice extends EventEmitter {
                     clearTimeout(timer);
                     res();
                 });
-                helper.kill("SIGTERM");
+                // Closing stdin is the helper's cross-platform graceful-shutdown
+                // signal. In particular, Node maps kill("SIGTERM") to an immediate
+                // TerminateProcess on Windows, which can interrupt Wintun inside a DLL
+                // call (0xc0000005) and leave an orphaned adapter. EOF lets main.go
+                // return normally and run its deferred session/adapter Close(). Keep
+                // SIGTERM/SIGKILL only as a fallback for a wedged helper.
+                if (helper.stdin && !helper.stdin.destroyed)
+                    helper.stdin.end();
+                setTimeout(() => {
+                    if (helper.exitCode === null && helper.signalCode === null) {
+                        helper.kill("SIGTERM");
+                    }
+                }, 1000).unref?.();
             });
         }
         this.emit("closed");
@@ -178,8 +208,9 @@ export class TunDevice extends EventEmitter {
     async openReal() {
         const helperPath = this.helperPath || this.findHelperBinary();
         if (!helperPath || !existsSync(helperPath)) {
+            const expected = helperBinaryRelativePath(process.platform, process.arch);
             throw new Error(`TUN helper binary not found: ${helperPath || "(none)"}\n` +
-                `Build it with: cd helper/tun-helper && go build -o bin/tun-helper-linux-amd64 .`);
+                `Expected package helper: ${expected || `${process.platform}/${process.arch} (unsupported)`}`);
         }
         // On Linux the helper creates a FIXED-name interface (agentnet0). If a
         // prior helper died uncleanly — e.g. "read tun: file descriptor in bad
@@ -301,27 +332,13 @@ export class TunDevice extends EventEmitter {
             resolve(moduleDir, "../../../bin"),
             resolve(process.cwd(), "bin"),
         ];
-        const platform = process.platform;
-        const arch = process.arch;
-        let suffix;
-        if (platform === "linux" && arch === "x64") {
-            suffix = "linux-amd64";
-        }
-        else if (platform === "darwin" && arch === "arm64") {
-            suffix = "darwin-arm64";
-        }
-        else if (platform === "darwin" && arch === "x64") {
-            suffix = "darwin-amd64";
-        }
-        else if (platform === "linux" && arch === "arm64") {
-            suffix = "linux-arm64";
-        }
-        else {
-            this.logger.warn(`Unsupported platform: ${platform}/${arch}`);
+        const relativePath = helperBinaryRelativePath(process.platform, process.arch);
+        if (!relativePath) {
+            this.logger.warn(`Unsupported platform: ${process.platform}/${process.arch}`);
             return null;
         }
         for (const dir of candidates) {
-            const path = resolve(dir, `tun-helper-${suffix}`);
+            const path = resolve(dir, relativePath);
             if (existsSync(path)) {
                 return path;
             }

package/docs/CONFIGURATION.md

@@ -77,8 +77,8 @@ dora:
 
 ### `network`
 
-- **`interface`** — TUN device name on Linux. macOS uses kernel-
-  assigned `utun*` regardless of this field.
+- **`interface`** — TUN device name on Linux and native Windows (Wintun).
+  macOS uses kernel-assigned `utun*` regardless of this field.
 - **`ip`** — fallback IP if dora can't be reached. **When dora is
   enabled and reachable, dora's allocation overrides this.**
 - **`subnet`** — `/16` is the only tested size today. Don't change

package/docs/INSTALL-WINDOWS.md

@@ -0,0 +1,137 @@
+# Install AgentNet natively on Windows
+
+AgentNet runs directly in 64-bit Windows. WSL is not required. The npm package
+contains a Windows helper and WireGuard's signed `wintun.dll`; AgentNet chooses
+the x64 or ARM64 files automatically.
+
+Supported targets:
+
+- Windows 10 or 11, x64 or ARM64
+- Windows Server 2016 or newer, x64 or ARM64
+- Node.js 20 or newer
+
+The TUN adapter and routes require Administrator rights. Carrier, the AgentNet
+protocol, ACLs, chat, the built-in CONNECT exit proxy, and the local router are
+the same as on Linux and macOS.
+
+## Install
+
+1. Install the current LTS release of [Node.js](https://nodejs.org/).
+2. Open **PowerShell as Administrator**.
+3. Run:
+
+   ```powershell
+   npm install -g @decentnetwork/lan
+   agentnet init --name my-windows-pc
+   agentnet service install
+   ```
+
+`service install` creates the `agentnet0` Wintun adapter, registers the
+`10.86.0.0/16` route, and installs an elevated `Decent AgentNet` startup task.
+The launcher restarts the daemon after a failure and starts it again at boot.
+
+No separate Wintun installer is needed. Do not download a driver DLL from a
+third-party site.
+
+## Verify
+
+In the same Administrator PowerShell:
+
+```powershell
+agentnet service status
+agentnet diag
+Get-NetAdapter -Name agentnet0
+Get-NetRoute -DestinationPrefix 10.86.0.0/16
+ping 10.86.156.164
+```
+
+Replace the final address with a live AgentNet peer. The first dora roster and
+Carrier sessions can take 60–90 seconds after a new installation.
+
+Follow the service log with:
+
+```powershell
+Get-Content -Wait "$env:USERPROFILE\.agentnet\agentnet-service.log"
+```
+
+Useful lifecycle commands:
+
+```powershell
+agentnet service restart
+agentnet service status
+agentnet service install --uninstall
+```
+
+Run these commands from an Administrator PowerShell. `agentnet restart` is a
+different command: it asks an already-running daemon to re-exec over local IPC;
+`agentnet service restart` works even when that daemon is stuck.
+
+## Make the Windows machine an exit node
+
+An exit node does not need WSL, Windows NAT, or the client-side HLS accelerator.
+Enable AgentNet's application-level CONNECT proxy and restart the service:
+
+```powershell
+agentnet proxy enable
+agentnet service restart
+```
+
+The proxy listens on the node's AgentNet virtual IP at port `8888` by default.
+AgentNet friend/ACL policy remains the authorization boundary. On the machine
+watching CCTV, run the multi-exit router with HLS acceleration:
+
+```powershell
+agentnet proxy router --listen 0.0.0.0 --hls-accel
+```
+
+Then point Chrome at `http://127.0.0.1:8889`. `--hls-accel` belongs on the
+watching/client router, not on each exit node.
+
+## Foreground debugging
+
+Stop the startup task first so two daemons do not share one identity:
+
+```powershell
+schtasks.exe /End /TN "Decent AgentNet"
+$env:DECENT_DEBUG = "1"
+$env:DECENT_DEBUG_VERBOSE = "1"
+agentnet up --real-tun
+```
+
+Press `Ctrl+C` when finished, then restore the task with
+`agentnet service restart`.
+
+## Troubleshooting
+
+| symptom | fix |
+|---|---|
+| `Access is denied`, route creation fails, or Wintun cannot create an adapter | Close the terminal and reopen PowerShell with **Run as administrator**. |
+| `Missing TUN helper` or `wintun.dll` is missing | Reinstall the current npm package. Antivirus quarantine is also worth checking. The helper and DLL must remain together in their `bin/windows-*` directory. |
+| Service is installed but `agentnet diag` cannot connect | Run commands from Administrator PowerShell and inspect `agentnet-service.log`; then use `agentnet service restart`. |
+| Only this Windows host cannot reach peers | Check `Get-NetRoute -DestinationPrefix 10.86.0.0/16` and ensure another VPN has not installed a more specific `10.86.*` route. |
+| Carrier shows a peer online but ping/messages stop after a restart | Upgrade both ends to the current AgentNet version; session rekey convergence requires compatible daemon versions. |
+| Native mode is blocked by enterprise policy | Use the previous WSL2 deployment as a fallback; do not run native and WSL daemons with the same identity at the same time. |
+
+## Implementation and trust
+
+- The helper is written in Go and uses the official
+  [`golang.zx2c4.com/wintun`](https://git.zx2c4.com/wintun-go/) binding.
+- Release packaging accepts only the official Wintun 0.14.1 archive with
+  SHA-256 `07c256185d6ee3652e09fa55c0b673e2624b565e02c4b9091c79ca7d2f24ef51`.
+- The release package includes Wintun's license and an asset manifest; npm
+  publishing fails if either architecture's DLL is missing or changed.
+
+The native helper is cross-compiled and unit-tested from the main repository.
+
+### Native validation
+
+Release `0.1.200` was validated on real Windows 11 x64 (build 26200) with
+Node.js 24.15.0 on July 15, 2026. The smoke test covered global npm install,
+Wintun creation, `/32` address and `/16` route, firewall, named-pipe CLI,
+dora roster, cross-node ICMP and chat, graceful service restart, adapter
+recreation, and HTTPS CONNECT egress. After restart, allow roughly 30–90
+seconds for dora roster/session convergence before treating an early
+`no-ipam-record` ping as a failure.
+
+Windows ARM64 is cross-compiled and packaged but has not yet had equivalent
+real-hardware validation.

package/docs/INSTALL.md

@@ -13,27 +13,18 @@ transparently between any two daemons that are Carrier friends.
 | | minimum |
 |---|---|
 | Node.js | **20+** |
-| OS | Linux (`x86_64`, `aarch64`), macOS (`aarch64`, `x86_64`), or **Windows 10 / 11 via WSL2** ([Windows guide](INSTALL-WINDOWS.md)) |
-| Root / sudo | Yes — needed to create the TUN device. The daemon drops back to user-mode for everything else. |
+| OS | Linux (`x86_64`, `aarch64`), macOS (`aarch64`, `x86_64`), or native 64-bit Windows 10/11/Server (`x64`, `ARM64`) ([Windows guide](INSTALL-WINDOWS.md)) |
+| Privilege | Root/sudo on Unix or Administrator on Windows — needed to create and configure the TUN device. |
 | Outbound network | TCP and UDP to public Carrier bootstrap nodes (ports 33445 + 443). No inbound port needed; no public IP needed. |
 
 ### Windows
 
-Windows **is** supported — but the daemon runs inside **WSL2** (Windows
-Subsystem for Linux), a real Linux environment Windows installs for you, not
-on Windows directly. Requirements:
+Windows runs AgentNet natively using the signed Wintun driver bundled with the
+npm package. Node selects the correct x64 or ARM64 helper automatically; WSL
+is no longer required. Installation and service commands must run from an
+Administrator PowerShell.
 
-- **Windows 11**, or **Windows 10 version 2004 or later** (build 19041+) —
-  this is what the one-command `wsl --install` needs.
-- **Fast (direct UDP) path needs Windows 11, version 22H2 or later.** There you
-  turn on WSL **mirrored networking mode**, which lets the direct UDP
-  hole-punch succeed (~200 ms — smooth for live video). On **Windows 10**
-  mirrored mode doesn't exist, so WSL's NAT blocks inbound UDP and the SDK
-  falls back to the TCP relay: it still works, just slower (fine for SSH, chat,
-  and most browsing; live sports may stutter).
-
-👉 **Non-technical step-by-step for Windows users: [INSTALL-WINDOWS.md](INSTALL-WINDOWS.md)**
-(install WSL → install Node.js → install decentlan, three steps).
+👉 **Native Windows step-by-step: [INSTALL-WINDOWS.md](INSTALL-WINDOWS.md)**
 
 ## Install
 
@@ -42,8 +33,8 @@ npm install -g @decentnetwork/lan
 ```
 
 This installs the `agentnet` CLI on `$PATH` along with platform-
-specific TUN helper binaries (we ship `linux-amd64`, `linux-arm64`,
-`darwin-amd64`, and `darwin-arm64`). Confirm:
+specific TUN helper binaries (Linux/macOS x64 + ARM64 and Windows x64 + ARM64).
+The Windows directories also contain the matching signed `wintun.dll`. Confirm:
 
 ```bash
 agentnet --help
@@ -59,8 +50,8 @@ sudo agentnet service install --config-dir $HOME/.agentnet
 
 That's it. `agentnet init` already points at the public dora and sends
 the one-time friend-request; `service install` writes a systemd unit
-(Linux) or LaunchDaemon (macOS) that runs the daemon as root with
-auto-restart and logs to `/var/log/agentnet.log`.
+(Linux), LaunchDaemon (macOS), or elevated startup task (Windows) with
+automatic restart.
 
 Wait ~60–90s, then verify:
 
@@ -105,7 +96,7 @@ The daemon will:
 1. Open a Carrier connection
 2. Register with dora and get a virtual IP (e.g. `10.86.1.12`)
 3. Pull the network roster and auto-friend every other peer in it
-4. Bring up `agentnet0` on Linux (or `utun*` on macOS) at that IP
+4. Bring up `agentnet0` on Linux/Windows (or `utun*` on macOS) at that IP
 5. Start a local DNS server for `*.decent` (default) so you can
    `ping my-laptop.decent`, `ssh peer-name.decent`, etc.
 
@@ -237,7 +228,8 @@ to stop. Drop the `.plist` file to disable persistence.
 
 ## Running CLI commands once the daemon is up
 
-The CLI talks to the daemon over a Unix socket in the config-dir.
+The CLI talks to the daemon over a Unix socket in the config-dir, or a named
+pipe derived from that directory on Windows.
 Most commands (`diag`, `ipam list`, `friends list`, `friends pending`,
 `resolve`, `dora autofriend`) just read or write config files — they
 **don't need sudo**:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decentnetwork/lan",
-  "version": "0.1.198",
+  "version": "0.1.200",
   "description": "Private virtual LAN for self-hosted services and AI agents, built on Elastos Carrier. NAT-traversal, name service, ACL, all over a peer-to-peer mesh — no public IP required.",
   "type": "module",
   "main": "./dist/index.js",
@@ -24,6 +24,7 @@
     "README.md",
     "LICENSE",
     "docs/INSTALL.md",
+    "docs/INSTALL-WINDOWS.md",
     "docs/CONFIGURATION.md"
   ],
   "sideEffects": false,
@@ -60,12 +61,16 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && chmod +x dist/cli/index.js && node scripts/build-ui.mjs && node scripts/build-console.mjs",
     "build:ui": "node scripts/build-ui.mjs",
-    "build:helper": "cd helper/tun-helper && go build -o ../../bin/tun-helper-$(go env GOOS)-$(go env GOARCH) .",
-    "build:helper:linux-amd64": "cd helper/tun-helper && GOOS=linux GOARCH=amd64 go build -o ../../bin/tun-helper-linux-amd64 .",
-    "build:helper:linux-arm64": "cd helper/tun-helper && GOOS=linux GOARCH=arm64 go build -o ../../bin/tun-helper-linux-arm64 .",
-    "build:helper:darwin-arm64": "cd helper/tun-helper && GOOS=darwin GOARCH=arm64 go build -o ../../bin/tun-helper-darwin-arm64 .",
-    "build:helper:darwin-amd64": "cd helper/tun-helper && GOOS=darwin GOARCH=amd64 go build -o ../../bin/tun-helper-darwin-amd64 .",
-    "build:helpers:all": "npm run build:helper:linux-amd64 && npm run build:helper:linux-arm64 && npm run build:helper:darwin-arm64 && npm run build:helper:darwin-amd64",
+    "build:helper": "cd helper/tun-helper && go build -buildvcs=false -o ../../bin/tun-helper-$(go env GOOS)-$(go env GOARCH) .",
+    "build:helper:linux-amd64": "cd helper/tun-helper && GOOS=linux GOARCH=amd64 go build -buildvcs=false -o ../../bin/tun-helper-linux-amd64 .",
+    "build:helper:linux-arm64": "cd helper/tun-helper && GOOS=linux GOARCH=arm64 go build -buildvcs=false -o ../../bin/tun-helper-linux-arm64 .",
+    "build:helper:darwin-arm64": "cd helper/tun-helper && GOOS=darwin GOARCH=arm64 go build -buildvcs=false -o ../../bin/tun-helper-darwin-arm64 .",
+    "build:helper:darwin-amd64": "cd helper/tun-helper && GOOS=darwin GOARCH=amd64 go build -buildvcs=false -o ../../bin/tun-helper-darwin-amd64 .",
+    "build:helper:windows-amd64": "mkdir -p bin/windows-amd64 && cd helper/tun-helper && GOOS=windows GOARCH=amd64 go build -buildvcs=false -o ../../bin/windows-amd64/tun-helper-windows-amd64.exe .",
+    "build:helper:windows-arm64": "mkdir -p bin/windows-arm64 && cd helper/tun-helper && GOOS=windows GOARCH=arm64 go build -buildvcs=false -o ../../bin/windows-arm64/tun-helper-windows-arm64.exe .",
+    "build:helpers:all": "npm run build:helper:linux-amd64 && npm run build:helper:linux-arm64 && npm run build:helper:darwin-arm64 && npm run build:helper:darwin-amd64 && npm run build:helper:windows-amd64 && npm run build:helper:windows-arm64",
+    "fetch:wintun": "node scripts/fetch-wintun.mjs",
+    "verify:wintun": "node scripts/verify-wintun.mjs",
     "build:all": "npm run build && npm run build:helper",
     "clean": "rm -rf dist bin",
     "dev": "node --loader ts-node/esm src/index.ts",
@@ -74,7 +79,7 @@
     "test:coverage": "vitest --coverage",
     "typecheck": "tsc --noEmit",
     "lint": "eslint src --ext .ts",
-    "prepublishOnly": "rm -rf dist && npm run build && npm run typecheck && npm run build:helpers:all",
+    "prepublishOnly": "rm -rf dist && npm run build && npm run typecheck && npm run build:helpers:all && npm run verify:wintun",
     "build:console": "node scripts/build-console.mjs"
   },
   "dependencies": {