@decentnetwork/lan 0.1.197 → 0.1.199

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